Skip to main content

bornera_core/connection/
recovery.rs

1//! Conservative ownership recovery after a deterministic owner can no longer be driven.
2
3use crate::{
4    ConnectionCore, ConnectionEpoch, Delivery, DiscardedWrite, OperationId, OperationPhase,
5    WriteFrame,
6};
7
8use super::journal::JournalOperation;
9use super::recovery_item::{recover_journal_operation, take_write, weaken};
10use crate::operation::OperationRecord;
11
12/// One nonterminal accepted operation recovered from a failed owner.
13#[derive(Clone, Debug, Eq, PartialEq)]
14#[non_exhaustive]
15pub struct RecoveredOperation<F> {
16    /// Accepted operation identity.
17    pub operation: OperationId,
18    /// Conservative delivery certainty at recovery.
19    pub delivery: Delivery,
20    /// Exact complete frame when write ownership had not released it.
21    pub frame: Option<F>,
22}
23
24/// Bounded recovery contents for one fixed connection epoch.
25#[derive(Clone, Debug, Eq, PartialEq)]
26#[non_exhaustive]
27pub struct ConnectionRecovery<F> {
28    /// Exact epoch that permanently owned the operations.
29    pub epoch: ConnectionEpoch,
30    /// Nonterminal operations in original wire order.
31    pub operations: Vec<RecoveredOperation<F>>,
32    /// Writer-owned frames that had no exact policy record.
33    pub unmatched_writes: Vec<DiscardedWrite<F>>,
34    /// Policy records and frame ownership disagreed during recovery.
35    pub ownership_diverged: bool,
36}
37
38impl<F: WriteFrame> ConnectionCore<F> {
39    /// Extracts every nonterminal operation and makes this aggregate unusable.
40    pub fn recover(&mut self) -> ConnectionRecovery<F> {
41        let epoch = self.machine.epoch;
42        let journal_armed = self.journal.armed();
43        let mut writes = self.writes.discard_all().into_writes();
44        writes.extend(self.journal.take_writes());
45        let journal_operations = self.journal.take_operations();
46        let mut current_records = Vec::with_capacity(self.machine.matching.pending_operations());
47        while let Some(record) = self.machine.matching.pop_front() {
48            current_records.push(Some(record));
49        }
50        let capacity = current_records
51            .len()
52            .saturating_add(journal_operations.len());
53        let mut operations = Vec::with_capacity(capacity);
54        let mut ownership_diverged = journal_armed || !journal_operations.is_empty();
55
56        self.recover_in_wire_order(
57            journal_operations,
58            &mut current_records,
59            &mut writes,
60            &mut operations,
61            &mut ownership_diverged,
62        );
63        if !writes.is_empty() {
64            ownership_diverged = true;
65        }
66        if self.machine.ledger.borrow().poisoned() {
67            ownership_diverged = true;
68        }
69        if self.poisoned.get().is_none() {
70            self.poisoned
71                .set(Some(crate::ConnectionCoreInvariant::Recovered));
72        }
73        ConnectionRecovery {
74            epoch,
75            operations,
76            unmatched_writes: writes,
77            ownership_diverged,
78        }
79    }
80
81    fn recover_in_wire_order(
82        &mut self,
83        journal_operations: Vec<JournalOperation>,
84        current_records: &mut [Option<OperationRecord>],
85        writes: &mut Vec<DiscardedWrite<F>>,
86        operations: &mut Vec<RecoveredOperation<F>>,
87        ownership_diverged: &mut bool,
88    ) {
89        let journal_ids: Vec<_> = journal_operations
90            .iter()
91            .map(|record| record.operation)
92            .collect();
93        let missing = journal_operations
94            .iter()
95            .filter(|journal| {
96                !current_records.iter().any(|current| {
97                    current
98                        .as_ref()
99                        .is_some_and(|current| current.id == journal.operation)
100                })
101            })
102            .count();
103        let original_len = current_records.len().saturating_add(missing);
104        if journal_operations
105            .iter()
106            .any(|record| record.wire_index >= original_len)
107        {
108            *ownership_diverged = true;
109        }
110        let mut journal: Vec<_> = journal_operations.into_iter().map(Some).collect();
111
112        for wire_index in 0..original_len {
113            let mut recovered_journal = false;
114            while let Some(index) = journal.iter().position(|record| {
115                record
116                    .as_ref()
117                    .is_some_and(|record| record.wire_index == wire_index)
118            }) {
119                if recovered_journal {
120                    *ownership_diverged = true;
121                }
122                recovered_journal = true;
123                let Some(journal_record) = journal[index].take() else {
124                    continue;
125                };
126                let current = current_records
127                    .iter_mut()
128                    .find(|record| {
129                        record
130                            .as_ref()
131                            .is_some_and(|record| record.id == journal_record.operation)
132                    })
133                    .and_then(Option::take);
134                if let Some(current) = current {
135                    if current.effect != journal_record.effect {
136                        *ownership_diverged = true;
137                    }
138                    self.recover_current_operation(current, writes, operations, ownership_diverged);
139                } else {
140                    recover_journal_operation(
141                        journal_record,
142                        writes,
143                        operations,
144                        ownership_diverged,
145                    );
146                }
147            }
148            if recovered_journal {
149                continue;
150            }
151            let current = current_records
152                .iter_mut()
153                .find(|record| {
154                    record
155                        .as_ref()
156                        .is_some_and(|record| !journal_ids.contains(&record.id))
157                })
158                .and_then(Option::take);
159            let Some(current) = current else {
160                *ownership_diverged = true;
161                continue;
162            };
163            self.recover_current_operation(current, writes, operations, ownership_diverged);
164        }
165
166        for current in current_records.iter_mut().filter_map(Option::take) {
167            *ownership_diverged = true;
168            self.recover_current_operation(current, writes, operations, ownership_diverged);
169        }
170        for journal_record in journal.into_iter().flatten() {
171            *ownership_diverged = true;
172            recover_journal_operation(journal_record, writes, operations, ownership_diverged);
173        }
174    }
175
176    fn recover_current_operation(
177        &mut self,
178        record: OperationRecord,
179        writes: &mut Vec<DiscardedWrite<F>>,
180        operations: &mut Vec<RecoveredOperation<F>>,
181        ownership_diverged: &mut bool,
182    ) {
183        let write = take_write(writes, record.id, record.effect);
184        if record.write_held != write.is_some() {
185            *ownership_diverged = true;
186        }
187        let (delivery, frame) = write.map_or((record.delivery, None), |write| {
188            (weaken(record.delivery, write.delivery), Some(write.frame))
189        });
190        if record.phase != OperationPhase::Terminal {
191            operations.push(RecoveredOperation {
192                operation: record.id,
193                delivery,
194                frame,
195            });
196        }
197        self.machine
198            .ledger
199            .borrow_mut()
200            .release_operation(record.reservation, record.write_held);
201    }
202}