1use std::collections::BTreeMap;
24use std::io;
25
26use serde_json::Value;
27
28use crate::format::{Header, LogLines, Meta, SESSION};
29use crate::session::note_meta;
30use crate::{FORMAT, META, MemoryStore, Repair, Session, SessionError, SessionMeta, Store};
31
32pub const KEPT: &str = "rig/kept/";
37
38pub type Verify<'a> = dyn Fn(&str, &Value) -> io::Result<()> + 'a;
43
44pub struct Chain {
47 steps: &'static [Step],
48}
49
50pub(crate) struct Step {
53 pub from: &'static str,
54 pub to: &'static str,
55 pub apply: fn(&mut Snapshot) -> Result<(), SessionError>,
56 #[cfg(test)]
58 pub fixture: fn() -> Result<MemoryStore, SessionError>,
59}
60
61pub const SHIPPED: Chain = Chain { steps: &[] };
64
65#[cfg(test)]
67const FIRST: &str = "rig-session/4";
68
69#[derive(Clone, Debug, Default, PartialEq, Eq)]
72pub(crate) struct Snapshot {
73 pub logs: BTreeMap<String, Vec<u8>>,
74 pub files: BTreeMap<String, Vec<u8>>,
75}
76
77impl Snapshot {
78 pub(crate) fn read(store: &dyn Store) -> io::Result<Self> {
79 let mut snapshot = Self::default();
80 for name in store.logs()? {
81 let bytes = store.read_log(&name)?;
82 snapshot.logs.insert(name, bytes);
83 }
84 for name in store.files()? {
85 if !name.starts_with(KEPT) {
86 let bytes = store.read_file(&name)?;
87 snapshot.files.insert(name, bytes);
88 }
89 }
90 Ok(snapshot)
91 }
92
93 pub(crate) fn write_to(&self, store: &dyn Store) -> Result<(), SessionError> {
95 for (name, bytes) in &self.logs {
96 store.replace_log(name, 0, bytes).map_err(io::Error::from)?;
97 }
98 for (name, bytes) in &self.files {
99 store.write_file(name, bytes)?;
100 }
101 Ok(())
102 }
103
104 fn format(&self) -> Result<Option<(String, Option<String>)>, SessionError> {
107 let mut named: Option<(String, Option<String>)> = None;
108 for (log, bytes) in &self.logs {
109 let lines = LogLines::parse(bytes.clone());
110 let Some((_, _, first)) = lines.iter().next() else {
111 continue;
112 };
113 let found = serde_json::from_slice::<Header>(first)
114 .ok()
115 .and_then(|header| header.format);
116 match &named {
117 Some((_, format)) if *format != found => {
118 let log = log.clone();
119 return Err(SessionError::Format { log, found });
120 }
121 Some(_) => {}
122 None => named = Some((log.clone(), found)),
123 }
124 }
125 Ok(named)
126 }
127}
128
129impl Chain {
130 pub fn migrate(&self, store: &dyn Store, verify: &Verify<'_>) -> Result<(), SessionError> {
154 let original = Snapshot::read(store)?;
155 let Some((log, found)) = original.format()? else {
156 return Ok(());
157 };
158 let from = match found.as_deref() {
159 Some(FORMAT) => return Ok(()),
160 Some(from) => from,
161 None => return Err(SessionError::Format { log, found }),
162 };
163 let kept = format!("{KEPT}{from}/");
164 if store.files()?.iter().any(|name| name.starts_with(&kept)) {
165 return Err(io::Error::new(
166 io::ErrorKind::AlreadyExists,
167 format!(
168 "a migration from {from} did not finish; the session as it was is \
169 under `{kept}`: put it back and remove it, or remove it, to migrate \
170 again"
171 ),
172 )
173 .into());
174 }
175 let mut migrated = original.clone();
176 let mut at = from;
177 while at != FORMAT {
178 let Some(step) = self.steps.iter().find(|step| step.from == at) else {
179 return Err(SessionError::Format { log, found });
180 };
181 (step.apply)(&mut migrated)?;
182 at = step.to;
183 }
184 check(&original, &migrated, verify)?;
185 keep(store, &original, &kept)?;
186 replace(store, &original, &migrated)?;
187 if Snapshot::read(store)? != migrated {
188 return Err(invalid("the migrated session reads back otherwise").into());
189 }
190 Ok(())
191 }
192}
193
194fn invalid(why: impl Into<String>) -> io::Error {
195 io::Error::new(io::ErrorKind::InvalidData, why.into())
196}
197
198fn check(
201 original: &Snapshot,
202 migrated: &Snapshot,
203 verify: &Verify<'_>,
204) -> Result<(), SessionError> {
205 if let Some(log) = original
206 .logs
207 .keys()
208 .find(|log| !migrated.logs.contains_key(*log))
209 {
210 return Err(invalid(format!("a migration step removed the log `{log}`")).into());
211 }
212 let store = MemoryStore::default();
213 migrated.write_to(&store)?;
214 let session = Session::read(&store)?;
215 if let Some(lost) = session
216 .repairs
217 .iter()
218 .find(|repair| matches!(repair, Repair::LostImage { .. }))
219 {
220 return Err(invalid(format!("the migrated session does not read whole: {lost}")).into());
221 }
222 let listed = |files: &BTreeMap<String, Vec<u8>>| {
223 let meta = files.get(META).map(|bytes| serde_json::from_slice(bytes));
224 meta.transpose()
225 .map(|meta: Option<SessionMeta>| meta.unwrap_or_default().listed)
226 };
227 let listed_before = listed(&original.files).unwrap_or_default();
228 let listed_after = listed(&migrated.files).map_err(invalid_json)?;
229 let before = saved(original);
230 let logs = session
231 .agents
232 .iter()
233 .map(|agent| (agent.id.as_str(), &agent.saved));
234 let logs = logs.chain([(SESSION, &session.saved)]);
235 let values = logs.flat_map(|(log, values)| changed(before.get(log), values));
236 let listed = changed(Some(&listed_before), &listed_after);
237 for (key, value) in values.chain(listed) {
238 verify(key, value)?;
239 }
240 Ok(())
241}
242
243fn changed<'a>(
245 before: Option<&'a BTreeMap<String, Value>>,
246 after: &'a BTreeMap<String, Value>,
247) -> impl Iterator<Item = (&'a String, &'a Value)> {
248 let kept =
249 move |key: &String, value: &Value| before.and_then(|before| before.get(key)) == Some(value);
250 after.iter().filter(move |&(key, value)| !kept(key, value))
251}
252
253fn saved(original: &Snapshot) -> BTreeMap<&str, BTreeMap<String, Value>> {
258 let fold = |bytes: &Vec<u8>| {
259 let (mut state, mut retired) = (BTreeMap::new(), false);
260 for (_, _, record) in LogLines::parse(bytes.clone()).iter().skip(1) {
261 let Ok(record) = serde_json::from_slice::<Value>(record) else {
262 continue;
263 };
264 let field = |name| record.get(name);
265 if field("type").and_then(Value::as_str) == Some("state")
266 && let Some(key) = field("key").and_then(Value::as_str)
267 {
268 let (key, value) = (key.to_owned(), field("value").cloned());
269 note_meta(Meta::State { key, value }, &mut state, &mut retired);
270 }
271 }
272 state
273 };
274 let logs = original.logs.iter();
275 logs.map(|(log, bytes)| (log.as_str(), fold(bytes)))
276 .collect()
277}
278
279fn invalid_json(error: serde_json::Error) -> io::Error {
280 invalid(error.to_string())
281}
282
283fn keep(store: &dyn Store, original: &Snapshot, kept: &str) -> io::Result<()> {
285 let logs = original
286 .logs
287 .iter()
288 .map(|(name, bytes)| (format!("{kept}logs/{name}.jsonl"), bytes));
289 let files = original
290 .files
291 .iter()
292 .map(|(name, bytes)| (format!("{kept}files/{name}"), bytes));
293 let copies: Vec<_> = logs.chain(files).collect();
294 for (name, bytes) in &copies {
295 store.write_file(name, bytes)?;
296 }
297 for (name, bytes) in &copies {
298 if store.read_file(name)? != **bytes {
299 return Err(invalid(format!(
300 "the kept copy `{name}` reads back otherwise"
301 )));
302 }
303 }
304 Ok(())
305}
306
307fn replace(
310 store: &dyn Store,
311 original: &Snapshot,
312 migrated: &Snapshot,
313) -> Result<(), SessionError> {
314 for name in original.files.keys() {
315 if !migrated.files.contains_key(name) {
316 store.remove_file(name)?;
317 }
318 }
319 for (name, bytes) in &migrated.files {
320 if original.files.get(name) != Some(bytes) {
321 store.write_file(name, bytes)?;
322 }
323 }
324 for (name, bytes) in &migrated.logs {
325 let was = original.logs.get(name);
326 if was == Some(bytes) {
327 continue;
328 }
329 let len = was.map_or(0, |was| was.len() as u64);
330 match store.replace_log(name, len, bytes) {
331 Err(crate::LogWriteError::Changed) => {
332 return Err(SessionError::Changed { log: name.clone() });
333 }
334 replaced => replaced.map_err(io::Error::from)?,
335 }
336 }
337 Ok(())
338}
339
340#[cfg(any(test, feature = "test-utils"))]
341pub mod testing;
342
343#[cfg(test)]
344mod tests;