Struct holochain::core::ribosome::guest_callback::validate::ValidateHostAccess

pub struct ValidateHostAccess {
    pub workspace: HostFnWorkspaceRead,
    pub network: HolochainP2pDna,
}

Fields

workspace: HostFnWorkspaceRead

network: HolochainP2pDna

Implementations

impl ValidateHostAccess

pub fn new(
    workspace: HostFnWorkspaceRead,
    network: HolochainP2pDna
) -> ValidateHostAccess

Examples found in repository

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

async fn run_validation_callback_inner<R>(
    invocation: ValidateInvocation,
    ribosome: &R,
    workspace_read: HostFnWorkspaceRead,
    network: HolochainP2pDna,
    (mut fetched_deps, recursion_depth): (HashSet<AnyDhtHash>, usize),
    mut visited_activity: HashSet<ChainFilter>,
) -> AppValidationResult<Outcome>
where
    R: RibosomeT,
{
    let validate_result = ribosome.run_validate(
        ValidateHostAccess::new(workspace_read.clone(), network.clone()),
        invocation.clone(),
    )?;
    match validate_result {
        ValidateResult::Valid => Ok(Outcome::Accepted),
        ValidateResult::Invalid(reason) => Ok(Outcome::Rejected(reason)),
        ValidateResult::UnresolvedDependencies(UnresolvedDependencies::Hashes(hashes)) => {
            // This is the base case where we've been recursing and start seeing
            // all the same hashes unresolved that we already tried to fetch.
            // At this point we should just give up on the inline recursing and
            // let some future background task attempt to fetch these hashes
            // again. Hopefully by then the hashes are fetchable.
            // 20 is a completely arbitrary max recursion depth.
            if recursion_depth > 20 || hashes.iter().all(|hash| fetched_deps.contains(hash)) {
                Ok(Outcome::AwaitingDeps(hashes))
            } else {
                let in_flight = hashes.into_iter().map(|hash| async {
                    let cascade_workspace = workspace_read.clone();
                    let mut cascade =
                        Cascade::from_workspace_and_network(&cascade_workspace, network.clone());
                    cascade
                        .fetch_record(hash.clone(), NetworkGetOptions::must_get_options())
                        .await?;
                    Ok(hash)
                });
                let results: Vec<_> = futures::stream::iter(in_flight)
                    // 10 is completely arbitrary.
                    .buffered(10)
                    .collect()
                    .await;
                let results: AppValidationResult<Vec<_>> = results.into_iter().collect();
                for hash in results? {
                    fetched_deps.insert(hash);
                }
                run_validation_callback_inner(
                    invocation,
                    ribosome,
                    workspace_read,
                    network,
                    (fetched_deps, recursion_depth + 1),
                    visited_activity,
                )
                .await
            }
        }
        ValidateResult::UnresolvedDependencies(UnresolvedDependencies::AgentActivity(
            author,
            filter,
        )) => {
            if recursion_depth > 20 || visited_activity.contains(&filter) {
                Ok(Outcome::AwaitingDeps(vec![author.into()]))
            } else {
                let cascade_workspace = workspace_read.clone();
                let mut cascade =
                    Cascade::from_workspace_and_network(&cascade_workspace, network.clone());
                cascade
                    .must_get_agent_activity(author.clone(), filter.clone())
                    .await?;
                visited_activity.insert(filter);
                run_validation_callback_inner(
                    invocation,
                    ribosome,
                    workspace_read,
                    network,
                    (fetched_deps, recursion_depth + 1),
                    visited_activity,
                )
                .await
            }
        }
    }
}

Trait Implementations

impl Clone for ValidateHostAccess

fn clone(&self) -> ValidateHostAccess

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ValidateHostAccess

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

Formats the value using the given formatter.

impl From<&ValidateHostAccess> for HostFnAccess

fn from(_: &ValidateHostAccess) -> Self

Converts to this type from the input type.

impl From<ValidateHostAccess> for HostContext

fn from(validate_host_access: ValidateHostAccess) -> Self

Converts to this type from the input type.