Struct RootRequestFailure 

pub struct RootRequestFailure { /* private fields */ }

Light, single-consumption source receipt: no exception body, original error, copied root facts, output handle, task/DB capability or account owner.

use saddle_observability::RootRequestFailure;
fn duplicate(f: RootRequestFailure) { let _ = f.clone(); }

use saddle_observability::RootRequestFailure;
let f = RootRequestFailure {};

Implementations

impl RootRequestFailure

pub fn original_capture(&self) -> OriginalCaptureState

pub fn occurrence(&self) -> DiagnosticOccurrence

pub fn submission(&self) -> DiagnosticSubmission

pub fn source_view(&self) -> &RequestExecutionView

pub fn map_classification(self, classification: DiagnosticCode) -> Self

Examples found in repository

examples/request_root_contract.rs (line 129)

fn main() {
    // Storage contract exercise only. R0/A/R must reserve the exact layouts before
    // this constructor is enabled in a real admitted or rejection path.
    let mut publisher = RequestRootPublisher::create(
        ContextLabel::checked("saddle").unwrap(),
        ContextFact::NotEstablished,
    )
    .unwrap();
    let root = publisher.reference();
    let early = root.view(
        RequestLocalFacts::new(RequestViewPhase::Reading).with_task(ContextFact::Present(17)),
    );
    let read_error = std::io::Error::from(std::io::ErrorKind::UnexpectedEof);
    let early_failure = RootDiagnosticScope::new(&early, None).source_error(
        &read_error,
        DiagnosticStage::RequestDecode,
        RootRequestEvent::Ingress,
        RootOutcomeFacts::default(),
    );
    let event = EventContext::new(
        RequestIdentity::new("request-a").unwrap(),
        RouteIdentity::new("example.live").unwrap(),
        1,
    )
    .unwrap();
    assert!(
        publisher
            .publish(
                request_identity_group(
                    &call("0", 1, "entry", "app", "example.live"),
                    &event,
                    ContextFact::Present(ContextLabel::checked("local").unwrap())
                )
                .unwrap()
            )
            .is_ok()
    );
    let active = early
        .refresh(&root)
        .unwrap()
        .with_phase(RequestViewPhase::Handler);
    // Formal Boundary style: real child Call and event originate from its actual
    // ProfuseContract request. Obs validates rather than inventing a child RPC.
    let child_event = EventContext::new(
        RequestIdentity::new("request-a").unwrap(),
        RouteIdentity::new("receipt.invoke").unwrap(),
        1,
    )
    .unwrap();
    let child = request_child_view(
        &active,
        &call("0.1", 2, "local", "profusecontract", "invoke"),
        &child_event,
    )
    .unwrap();
    assert!(active.same_request(&child));
    let (_, issuer) = DbPhysicalDispositionIssuer::issue().into_startup_and_request_issuer();
    let (request, execution) = issuer.issue_request().unwrap();
    // Real D passes &sqlx::Error here before driver_ref/business mapping. This
    // standalone example uses the standard Error contract, with no DB dependency.
    let raw_error = std::io::Error::new(
        std::io::ErrorKind::PermissionDenied,
        "original driver description",
    );
    let db_failure = database_source(&active, &request, &execution, None, &raw_error);
    drop(raw_error);
    let supervised = RootSupervisionReturn::<()>::failed(
        db_failure.map_classification(DiagnosticCode::new("handler.failed").unwrap()),
    );
    let failure = supervised.consume().err().unwrap();
    // Public projections contain no source body or root. Real Runtime must also
    // finish the original physical pair, then drop all views before settlement.
    let public = failure
        .finish(&active, None, RootOutcomeFacts::default())
        .ok()
        .unwrap();
    let early_public = early_failure
        .finish(&active, None, RootOutcomeFacts::default())
        .ok()
        .unwrap();
    let observer = Observer::with_writer(ObserverConfig::default(), std::io::sink()).unwrap();
    let completed = RootDiagnosticScope::new(&active, None)
        .start_stage(&observer, RootRequestEvent::Response)
        .finish_nonfailure(RootOutcomeFacts {
            axes: DiagnosticOutcomeAxes {
                operation: OperationOutcome::Succeeded,
                ..Default::default()
            },
            ..Default::default()
        })
        .ok()
        .unwrap();
    assert_eq!(completed, DiagnosticSubmission::OutputUnavailable);
    assert_eq!(
        RootDiagnosticScope::new(&active, None).ordinary(
            &observer,
            RootRequestEvent::Handler,
            RootOutcomeFacts::default()
        ),
        DiagnosticSubmission::Enqueued
    );
    drop((publisher, root, early, active, child));
    assert_eq!(
        public.source_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    assert_eq!(
        early_public.terminal_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    for (name, (payload, shared)) in ["root", "view", "child"]
        .into_iter()
        .zip(saddle_core::request_context::request_context_layouts())
    {
        println!(
            "layout {name}: payload={} align={} arc_allocation={} arc_align={}",
            payload.size(),
            payload.align(),
            shared.size(),
            shared.align()
        );
    }
    println!(
        "layout receipt={} public={} root_ref={} view_ref={} identity_input={} bounded_detail={} borrowed_stage={}",
        size_of::<RootRequestFailure>(),
        size_of::<PublicRequestFailure>(),
        size_of::<RequestRootRef>(),
        size_of::<RequestExecutionView>(),
        size_of::<RequestIdentityGroup>(),
        size_of::<BoundedDiagnostic>(),
        size_of::<RootActiveStage<'static>>()
    );
    println!("C consumer contract GO; production reservation/lifecycle NOT_RUN");
    let layout = saddle_observability::root_diagnostic::request_logging_layouts();
    let (stream, cycle, payload) = saddle_observability::root_diagnostic::original_capture_layout();
    println!(
        "layout original_stream={} align={} cycle_detector={} align={} payload_limit={} total_content_limit=none",
        stream.size(),
        stream.align(),
        cycle.size(),
        cycle.align(),
        payload
    );
    println!(
        "layout source_frame={} source_record={} emergency_packet={} emergency_slots={} ordinary_command={} ordinary_payload_max={}",
        layout.source_frame.size(),
        layout.source_record.size(),
        layout.emergency_packet.size(),
        layout.emergency_slots,
        layout.ordinary_command.size(),
        layout.ordinary_encoded_bytes_max
    );
}

pub fn boundary( self, current: &RequestExecutionView, output: Option<&EmergencyDiagnosticHandle>, stage: RootRequestEvent, axes: RootOutcomeFacts, ) -> Result<(Self, DiagnosticSubmission), Self>

Foreign-root rejection returns the original receipt for a legitimate retry.

pub fn finish( self, current: &RequestExecutionView, output: Option<&EmergencyDiagnosticHandle>, axes: RootOutcomeFacts, ) -> Result<PublicRequestFailure, Self>

Submit final reference, then consume all receipt references. Caller must release its other views/root before settling the original account.

Examples found in repository

examples/request_root_contract.rs (line 135)

fn main() {
    // Storage contract exercise only. R0/A/R must reserve the exact layouts before
    // this constructor is enabled in a real admitted or rejection path.
    let mut publisher = RequestRootPublisher::create(
        ContextLabel::checked("saddle").unwrap(),
        ContextFact::NotEstablished,
    )
    .unwrap();
    let root = publisher.reference();
    let early = root.view(
        RequestLocalFacts::new(RequestViewPhase::Reading).with_task(ContextFact::Present(17)),
    );
    let read_error = std::io::Error::from(std::io::ErrorKind::UnexpectedEof);
    let early_failure = RootDiagnosticScope::new(&early, None).source_error(
        &read_error,
        DiagnosticStage::RequestDecode,
        RootRequestEvent::Ingress,
        RootOutcomeFacts::default(),
    );
    let event = EventContext::new(
        RequestIdentity::new("request-a").unwrap(),
        RouteIdentity::new("example.live").unwrap(),
        1,
    )
    .unwrap();
    assert!(
        publisher
            .publish(
                request_identity_group(
                    &call("0", 1, "entry", "app", "example.live"),
                    &event,
                    ContextFact::Present(ContextLabel::checked("local").unwrap())
                )
                .unwrap()
            )
            .is_ok()
    );
    let active = early
        .refresh(&root)
        .unwrap()
        .with_phase(RequestViewPhase::Handler);
    // Formal Boundary style: real child Call and event originate from its actual
    // ProfuseContract request. Obs validates rather than inventing a child RPC.
    let child_event = EventContext::new(
        RequestIdentity::new("request-a").unwrap(),
        RouteIdentity::new("receipt.invoke").unwrap(),
        1,
    )
    .unwrap();
    let child = request_child_view(
        &active,
        &call("0.1", 2, "local", "profusecontract", "invoke"),
        &child_event,
    )
    .unwrap();
    assert!(active.same_request(&child));
    let (_, issuer) = DbPhysicalDispositionIssuer::issue().into_startup_and_request_issuer();
    let (request, execution) = issuer.issue_request().unwrap();
    // Real D passes &sqlx::Error here before driver_ref/business mapping. This
    // standalone example uses the standard Error contract, with no DB dependency.
    let raw_error = std::io::Error::new(
        std::io::ErrorKind::PermissionDenied,
        "original driver description",
    );
    let db_failure = database_source(&active, &request, &execution, None, &raw_error);
    drop(raw_error);
    let supervised = RootSupervisionReturn::<()>::failed(
        db_failure.map_classification(DiagnosticCode::new("handler.failed").unwrap()),
    );
    let failure = supervised.consume().err().unwrap();
    // Public projections contain no source body or root. Real Runtime must also
    // finish the original physical pair, then drop all views before settlement.
    let public = failure
        .finish(&active, None, RootOutcomeFacts::default())
        .ok()
        .unwrap();
    let early_public = early_failure
        .finish(&active, None, RootOutcomeFacts::default())
        .ok()
        .unwrap();
    let observer = Observer::with_writer(ObserverConfig::default(), std::io::sink()).unwrap();
    let completed = RootDiagnosticScope::new(&active, None)
        .start_stage(&observer, RootRequestEvent::Response)
        .finish_nonfailure(RootOutcomeFacts {
            axes: DiagnosticOutcomeAxes {
                operation: OperationOutcome::Succeeded,
                ..Default::default()
            },
            ..Default::default()
        })
        .ok()
        .unwrap();
    assert_eq!(completed, DiagnosticSubmission::OutputUnavailable);
    assert_eq!(
        RootDiagnosticScope::new(&active, None).ordinary(
            &observer,
            RootRequestEvent::Handler,
            RootOutcomeFacts::default()
        ),
        DiagnosticSubmission::Enqueued
    );
    drop((publisher, root, early, active, child));
    assert_eq!(
        public.source_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    assert_eq!(
        early_public.terminal_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    for (name, (payload, shared)) in ["root", "view", "child"]
        .into_iter()
        .zip(saddle_core::request_context::request_context_layouts())
    {
        println!(
            "layout {name}: payload={} align={} arc_allocation={} arc_align={}",
            payload.size(),
            payload.align(),
            shared.size(),
            shared.align()
        );
    }
    println!(
        "layout receipt={} public={} root_ref={} view_ref={} identity_input={} bounded_detail={} borrowed_stage={}",
        size_of::<RootRequestFailure>(),
        size_of::<PublicRequestFailure>(),
        size_of::<RequestRootRef>(),
        size_of::<RequestExecutionView>(),
        size_of::<RequestIdentityGroup>(),
        size_of::<BoundedDiagnostic>(),
        size_of::<RootActiveStage<'static>>()
    );
    println!("C consumer contract GO; production reservation/lifecycle NOT_RUN");
    let layout = saddle_observability::root_diagnostic::request_logging_layouts();
    let (stream, cycle, payload) = saddle_observability::root_diagnostic::original_capture_layout();
    println!(
        "layout original_stream={} align={} cycle_detector={} align={} payload_limit={} total_content_limit=none",
        stream.size(),
        stream.align(),
        cycle.size(),
        cycle.align(),
        payload
    );
    println!(
        "layout source_frame={} source_record={} emergency_packet={} emergency_slots={} ordinary_command={} ordinary_payload_max={}",
        layout.source_frame.size(),
        layout.source_record.size(),
        layout.emergency_packet.size(),
        layout.emergency_slots,
        layout.ordinary_command.size(),
        layout.ordinary_encoded_bytes_max
    );
}