Function handle_request

atomic-cli/src/commands/agent/owner.rs:944–1311

(store: &RedbChangeStore, frame: RequestFrame)

}

fn handle_request(store: &RedbChangeStore, frame: RequestFrame) -> (ResponseFrame, bool) {
    let request_id = frame.request_id;
    if frame.version != PROTOCOL_VERSION {
        return (
            ResponseFrame {
                version: PROTOCOL_VERSION,
                request_id,
                response: OwnerResponse::Error {
                    code: "unsupported-version".to_string(),
                    message: format!(
                        "client requested protocol {}, owner supports {}",
                        frame.version, PROTOCOL_VERSION
                    ),
                },
            },
            false,
        );
    }

    let (response, shutdown) = match frame.request {
        OwnerRequest::Ping => (
            OwnerResponse::Pong {
                pid: std::process::id(),
                frozen_envelope_paging: true,
            },
            false,
        ),
        OwnerRequest::ReserveProvenanceTurn {
            session_id,
            turn_number,
            now,
        } => match store.reserve_provenance_turn(&session_id, turn_number, now) {
            Ok(turn) => (
                OwnerResponse::ProvenanceTurn {
                    turn,
                    // reserve_provenance_turn returns only after txn.commit().
                    committed: true,
                },
                false,
            ),
            Err(error) => (
                OwnerResponse::Error {
                    code: "provenance-store".to_string(),
                    message: error.to_string(),
                },
                false,
            ),
        },
        OwnerRequest::AppendProvenanceEnvelopes {
            provenance_id,
            expected_generation,
            envelopes,
            now,
        } => {
            owner_failpoint("before-envelope-commit");
            let batch: Vec<_> = envelopes
                .iter()
                .map(|envelope| (envelope.event_id.as_str(), envelope.bytes.as_slice()))