rehearse 0.3.0

Effect-aware operation planning with describe, dry-run, and execute modes.
Documentation
use crate::operation::NodeRunError;
use crate::plan::store::ValueStore;
use crate::InvariantError;
use crate::{
    DryRunAction, DryRunPolicy, DryRunReport, NodeOutcome, NodeReport, NoopProgress,
    OperationMetadata, Plan, ProgressEvent, ProgressListener, ProgressMode, ProgressNode,
    ProgressOutcome, ProgressPlanOutcome,
};

pub async fn dry_run<C, T, E, P>(plan: &Plan<C, T, E>, context: &C, policy: &P) -> DryRunReport<E>
where
    C: Sync + 'static,
    T: Clone + Send + Sync + 'static,
    E: Send + 'static,
    P: DryRunPolicy,
{
    let mut progress = NoopProgress;
    dry_run_with_listener(plan, context, policy, &mut progress).await
}

pub async fn dry_run_with_listener<C, T, E, P, L>(
    plan: &Plan<C, T, E>,
    context: &C,
    policy: &P,
    listener: &mut L,
) -> DryRunReport<E>
where
    C: Sync + 'static,
    T: Clone + Send + Sync + 'static,
    E: Send + 'static,
    P: DryRunPolicy,
    L: ProgressListener<E> + ?Sized,
{
    let mut store = ValueStore::new(plan.owner);
    let mut report = DryRunReport::new(plan.name());
    let total_nodes = plan.nodes.len();

    listener.on_event(ProgressEvent::PlanStarted {
        mode: ProgressMode::DryRun,
        plan_name: plan.name(),
        total_nodes,
    });

    for (index, node) in plan.nodes.iter().enumerate() {
        let metadata = node.metadata();
        let progress_node = ProgressNode::new(
            node.id(),
            index + 1,
            total_nodes,
            metadata.name(),
            metadata.impact(),
        );
        listener.on_event(ProgressEvent::NodeStarted {
            mode: ProgressMode::DryRun,
            node: progress_node,
        });

        let outcome = match policy.action(node.metadata()) {
            DryRunAction::Skip => NodeOutcome::Skipped {
                reason: impact_reason(metadata),
            },
            DryRunAction::Deny => NodeOutcome::Denied {
                reason: impact_reason(metadata),
            },
            DryRunAction::Run => {
                let missing = node
                    .dependencies()
                    .iter()
                    .copied()
                    .filter(|dependency| !store.contains(*dependency))
                    .collect::<Vec<_>>();
                if !missing.is_empty() {
                    NodeOutcome::Blocked {
                        missing_dependencies: missing,
                    }
                } else {
                    match node.run(context, &store).await {
                        Ok(output) => {
                            store.insert_erased(node.id(), output);
                            NodeOutcome::Executed
                        }
                        Err(NodeRunError::Operation(error)) => NodeOutcome::Failed { error },
                        Err(NodeRunError::Internal(source)) => NodeOutcome::Internal {
                            error: InvariantError::Input {
                                node: node.id(),
                                source,
                            },
                        },
                    }
                }
            }
        };

        listener.on_event(ProgressEvent::NodeFinished {
            mode: ProgressMode::DryRun,
            node: progress_node,
            outcome: progress_outcome(&outcome),
        });
        report.push(NodeReport::new(node.id(), metadata, outcome));
    }

    listener.on_event(ProgressEvent::PlanFinished {
        mode: ProgressMode::DryRun,
        plan_name: plan.name(),
        total_nodes,
        outcome: ProgressPlanOutcome::from(report.status()),
    });

    report
}

fn impact_reason(metadata: &OperationMetadata) -> String {
    format!("{} operation", metadata.impact())
}

fn progress_outcome<E>(outcome: &NodeOutcome<E>) -> ProgressOutcome<'_, E> {
    match outcome {
        NodeOutcome::Executed => ProgressOutcome::Executed,
        NodeOutcome::Skipped { reason } => ProgressOutcome::Skipped { reason },
        NodeOutcome::Denied { reason } => ProgressOutcome::Denied { reason },
        NodeOutcome::Blocked {
            missing_dependencies,
        } => ProgressOutcome::Blocked {
            missing_dependencies,
        },
        NodeOutcome::Failed { error } => ProgressOutcome::Failed { error },
        NodeOutcome::Internal { error } => ProgressOutcome::Internal { error },
    }
}