bornera_core/connection/
recovery.rs1use 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#[derive(Clone, Debug, Eq, PartialEq)]
14#[non_exhaustive]
15pub struct RecoveredOperation<F> {
16 pub operation: OperationId,
18 pub delivery: Delivery,
20 pub frame: Option<F>,
22}
23
24#[derive(Clone, Debug, Eq, PartialEq)]
26#[non_exhaustive]
27pub struct ConnectionRecovery<F> {
28 pub epoch: ConnectionEpoch,
30 pub operations: Vec<RecoveredOperation<F>>,
32 pub unmatched_writes: Vec<DiscardedWrite<F>>,
34 pub ownership_diverged: bool,
36}
37
38impl<F: WriteFrame> ConnectionCore<F> {
39 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}