1use std::collections::BTreeSet;
2use std::fs;
3use std::io::{self, ErrorKind};
4use std::path::{Path, PathBuf};
5
6use anyhow::{Context, Result, anyhow, bail, ensure};
7
8use super::aside::{RESTORE_MARKER, aside_path, carry_over, create_private_dir};
9use super::device::sync_dir;
10use super::hardware::{HardwareSource, SystemHardware};
11use super::storage::create_device_keys_with;
12use super::{
13 DEVICE_KEY_FILE, DEVICE_PUB_FILE, DeviceKeys, HARDWARE_BINDING_FILE, HeldEpoch, IdentityTag,
14 KeyStorage, NEXT_STORE_KEY_FILE, RecoveryPhrase, SEALED_DEVICE_KEY_FILE, STORE_KEY_FILE,
15 StoreKey, WRAPPED_STORE_KEY_FILE, found_identity, refresh_wrapped_store_key,
16 unwrap_store_key_with_epochs, unwrap_store_key_with_phrase, wrap, wrap_for_recovery,
17 write_store_key,
18};
19use crate::machine::MachineIdentity;
20use crate::sqlite_store::SqliteStore;
21use crate::sqlite_store::encrypt_migration::{
22 FileState, PLAINTEXT_COPY_PREFIX, RewriteTo, db_file_state,
23};
24use crate::store::StoreAdmin;
25use crate::write_queue;
26
27const DB_FILE: &str = "brain.db";
28const MACHINE_FILE: &str = "machine.toml";
29const CONFIG_FILE: &str = "config.toml";
30
31const LEFT_BEHIND: &[&str] = &[
34 MACHINE_FILE,
35 DEVICE_KEY_FILE,
36 SEALED_DEVICE_KEY_FILE,
37 HARDWARE_BINDING_FILE,
38 DEVICE_PUB_FILE,
39 "sync.key",
40 "migrated-peers.json",
41 "api.token",
42 ".api.token.lock",
43 "sync-peers",
44 "clock-reading",
45 "service.json",
46 "brain.db-shm",
47 STORE_KEY_FILE,
48 NEXT_STORE_KEY_FILE,
49 "brain.db.enc",
50 "brain.db.enc-journal",
51 "brain.db.enc-wal",
52 "brain.db.enc-shm",
53];
54
55const LEFT_BEHIND_PREFIXES: &[&str] = &[".device.key.", ".store.key.", PLAINTEXT_COPY_PREFIX];
58
59pub fn left_behind(name: &str) -> bool {
61 LEFT_BEHIND.contains(&name) || LEFT_BEHIND_PREFIXES.iter().any(|p| name.starts_with(p))
62}
63
64const HOST_FILES: &[&str] = &["service.json"];
66
67pub struct RestoreRequest<'a> {
68 pub backup: &'a Path,
70 pub data_dir: &'a Path,
72 pub phrase: &'a RecoveryPhrase,
73 pub storage: &'a KeyStorage,
74 pub now_micros: i64,
75}
76
77#[derive(Clone, Copy)]
79#[non_exhaustive]
80pub enum BackupKeys<'a> {
81 Phrase(&'a RecoveryPhrase),
83 Epochs(&'a [HeldEpoch]),
86}
87
88pub struct BackupRestore<'a> {
89 pub backup: &'a Path,
91 pub data_dir: &'a Path,
93 pub keys: BackupKeys<'a>,
94 pub storage: &'a KeyStorage,
95 pub now_micros: i64,
96}
97
98#[derive(Debug)]
99#[non_exhaustive]
100pub struct Restored {
101 pub machine: MachineIdentity,
102 pub identity: IdentityTag,
103 pub opened: Vec<IdentityTag>,
106 pub phrase: RecoveryPhrase,
108 pub moved_aside: Option<PathBuf>,
110}
111
112pub fn restore_backup(req: &RestoreRequest<'_>) -> Result<Restored> {
120 restore_backup_with(&BackupRestore {
121 backup: req.backup,
122 data_dir: req.data_dir,
123 keys: BackupKeys::Phrase(req.phrase),
124 storage: req.storage,
125 now_micros: req.now_micros,
126 })
127}
128
129pub fn restore_backup_with(req: &BackupRestore<'_>) -> Result<Restored> {
132 restore_with_hardware(req, &SystemHardware)
133}
134
135fn restore_with_hardware(
136 req: &BackupRestore<'_>,
137 hardware: &dyn HardwareSource,
138) -> Result<Restored> {
139 let backup = check_backup(req.backup)?;
140 if let Ok(target) = fs::canonicalize(req.data_dir) {
141 ensure!(
142 target != backup,
143 "the backup is the data dir itself; restore from a copy"
144 );
145 }
146 let parent = parent_of(req.data_dir)?;
147 fs::create_dir_all(&parent).with_context(|| format!("creating {}", parent.display()))?;
148 let base = dir_name(req.data_dir)?;
149 let staging_prefix = format!(".{base}.restoring-");
150 remove_stale_staging(&parent, &staging_prefix, &backup);
151 let staging = parent.join(format!("{staging_prefix}{}", uuid::Uuid::new_v4().simple()));
152 let restored = match prepare(req, &backup, &staging, hardware) {
153 Ok(restored) => restored,
154 Err(e) => return Err(with_staging_removed(e, &staging)),
155 };
156 let moved_aside = match swap_in(req.data_dir, &staging, &base, req.now_micros, rename) {
157 Ok(moved) => moved,
158 Err(Swap::Untouched(e)) => return Err(with_staging_removed(e, &staging)),
159 Err(Swap::Stranded(e)) => return Err(e),
160 };
161 if let Err(e) = sync_dir(&parent) {
162 tracing::warn!("the restore is in place but not yet flushed to disk: {e:#}");
163 }
164 Ok(Restored {
165 moved_aside,
166 ..restored
167 })
168}
169
170fn reseal_backup_queue(backup: &Path, staging: &Path, device: &DeviceKeys) -> Result<()> {
174 let queue = staging.join(write_queue::DIR_NAME);
175 if !queue.is_dir() {
176 return Ok(());
177 }
178 let old = match DeviceKeys::load(&backup.join(DEVICE_KEY_FILE)) {
179 Ok(Some(old)) => old,
180 Ok(None) => return Ok(()),
181 Err(e) => {
182 tracing::warn!("sealed queued writes in the backup stay unreadable: {e:#}");
183 return Ok(());
184 }
185 };
186 write_queue::reseal_dir(&queue, old.age_identity(), &[device.age_recipient()])?;
187 Ok(())
188}
189
190pub fn check_backup(backup: &Path) -> Result<PathBuf> {
193 let canonical = fs::canonicalize(backup)
194 .with_context(|| format!("reading the backup {}", backup.display()))?;
195 ensure!(
196 canonical.join(DB_FILE).is_file(),
197 "{} holds no {DB_FILE}; name a copy of a second-brain data dir",
198 canonical.display()
199 );
200 Ok(canonical)
201}
202
203fn prepare(
204 req: &BackupRestore<'_>,
205 backup: &Path,
206 staging: &Path,
207 hardware: &dyn HardwareSource,
208) -> Result<Restored> {
209 if let BackupKeys::Epochs(held) = req.keys {
210 ensure!(
211 !held.is_empty(),
212 "no key epoch was given, so the backup cannot be opened"
213 );
214 }
215 create_private_dir(staging)?;
216 copy_tree(backup, staging, true)?;
217 let machine = MachineIdentity::load_or_create(staging)?;
218 let device = create_device_keys_with(staging, req.storage, hardware)?;
219 reseal_backup_queue(backup, staging, &device)?;
220 let store = open_backup_store(&staging.join(DB_FILE), staging, req.keys, &machine.id)
221 .context("opening the restored database")?;
222 store.register_machine(&machine)?;
223
224 let reopened;
225 let old_epochs: &[HeldEpoch] = match req.keys {
226 BackupKeys::Phrase(phrase) => {
227 reopened =
228 reopen_old_epochs(&store, phrase, &device, req.now_micros).with_context(|| {
229 format!("opening {} with the recovery phrase", backup.display())
230 })?;
231 &reopened
232 }
233 BackupKeys::Epochs(held) => {
234 keep_epochs(&store, held, &device, req.now_micros)?;
235 held
236 }
237 };
238
239 let phrase = RecoveryPhrase::generate()?;
240 let recipient = phrase.recipient()?;
241 let founded = found_identity(
242 &store,
243 &device,
244 &machine.name,
245 std::slice::from_ref(&recipient),
246 req.now_micros,
247 )?;
248 for held in old_epochs {
249 wrap_for_recovery(
250 &store,
251 &held.identity,
252 &[(held.epoch, &held.key)],
253 std::slice::from_ref(&recipient),
254 )?;
255 }
256 if cfg!(feature = "encryption") {
257 rekey_restored(&store, staging, &device)?;
258 }
259 drop(store);
260 let opened: BTreeSet<&str> = old_epochs.iter().map(|h| h.identity.as_str()).collect();
261 let opened = opened
262 .into_iter()
263 .map(|t| IdentityTag::from(t.to_string()))
264 .collect();
265 sync_tree(staging)?;
266 Ok(Restored {
267 machine,
268 identity: founded.tag,
269 opened,
270 phrase,
271 moved_aside: None,
272 })
273}
274
275fn open_backup_store(
279 db: &Path,
280 staging: &Path,
281 keys: BackupKeys<'_>,
282 machine_id: &str,
283) -> Result<SqliteStore> {
284 match db_file_state(db)? {
285 FileState::Encrypted => {
286 let unwrapped = match keys {
287 BackupKeys::Phrase(phrase) => unwrap_store_key_with_phrase(staging, phrase)?,
288 BackupKeys::Epochs(held) => unwrap_store_key_with_epochs(staging, held)?,
289 };
290 let key = unwrapped.ok_or_else(|| {
291 anyhow!(
292 "the backup's {DB_FILE} is encrypted but it holds no \
293 {WRAPPED_STORE_KEY_FILE}; restore a copy of the whole data dir"
294 )
295 })?;
296 SqliteStore::open_with_key(db, machine_id.to_string(), &key)
297 }
298 _ => SqliteStore::open(db, machine_id.to_string()),
299 }
300}
301
302fn rekey_restored(store: &SqliteStore, staging: &Path, device: &DeviceKeys) -> Result<()> {
306 let key = StoreKey::generate()?;
307 write_store_key(staging, STORE_KEY_FILE, &key, device)?;
308 store
309 .rewrite_under_key(RewriteTo::Key(&key))
310 .context("rewriting the restored store under a new store key")?;
311 refresh_wrapped_store_key(store, staging, device, &key)
312 .context("wrapping the new store key to the new identity")?;
313 Ok(())
314}
315
316fn reopen_old_epochs(
319 store: &SqliteStore,
320 phrase: &RecoveryPhrase,
321 device: &DeviceKeys,
322 now_micros: i64,
323) -> Result<Vec<HeldEpoch>> {
324 let identity = phrase.identity()?;
325 let own = store.machine_id().to_string();
326 let recipient = device.age_recipient();
327 let mut opened = Vec::new();
328 for envelope in store.recovery_envelopes(&phrase.recipient()?)? {
329 let key = match envelope.open(&identity) {
330 Ok(key) => key,
331 Err(e) => {
332 tracing::warn!("skipping a recovery envelope the phrase cannot open: {e:#}");
333 continue;
334 }
335 };
336 let rewrapped = wrap(
337 &key,
338 envelope.epoch.number,
339 &envelope.identity_tag,
340 &recipient,
341 Some(own.clone()),
342 )?;
343 store.put_keys_durably(
344 &envelope.identity_tag,
345 &[envelope.epoch],
346 &[rewrapped],
347 now_micros,
348 )?;
349 opened.push(HeldEpoch::new(envelope.identity_tag, envelope.epoch, key));
350 }
351 if opened.is_empty() {
352 bail!(
353 "this recovery phrase opens no key in the backup; check the phrase, or restore a \
354 backup of a device that trusted it"
355 );
356 }
357 Ok(opened)
358}
359
360fn keep_epochs(
363 store: &SqliteStore,
364 held: &[HeldEpoch],
365 device: &DeviceKeys,
366 now_micros: i64,
367) -> Result<()> {
368 let own = store.machine_id().to_string();
369 let recipient = device.age_recipient();
370 for h in held {
371 let envelope = wrap(
372 &h.key,
373 h.epoch.number,
374 &h.identity,
375 &recipient,
376 Some(own.clone()),
377 )?;
378 store.put_keys_durably(&h.identity, &[h.epoch], &[envelope], now_micros)?;
379 }
380 Ok(())
381}
382
383enum Swap {
384 Untouched(anyhow::Error),
386 Stranded(anyhow::Error),
388}
389
390fn rename(from: &Path, to: &Path) -> io::Result<()> {
391 fs::rename(from, to)
392}
393
394fn swap_in(
395 data_dir: &Path,
396 staging: &Path,
397 base: &str,
398 now_micros: i64,
399 rename: impl Fn(&Path, &Path) -> io::Result<()>,
400) -> Result<Option<PathBuf>, Swap> {
401 let parent = parent_of(data_dir).map_err(Swap::Untouched)?;
402 let moved_aside = match fs::symlink_metadata(data_dir) {
403 Ok(_) => {
404 let carried = HOST_FILES
405 .iter()
406 .try_for_each(|name| carry_over(&data_dir.join(name), &staging.join(name)))
407 .and_then(|()| {
408 if staging.join(CONFIG_FILE).exists() {
409 return Ok(());
410 }
411 carry_over(&data_dir.join(CONFIG_FILE), &staging.join(CONFIG_FILE))
412 })
413 .and_then(|()| sync_dir(staging));
414 carried.map_err(Swap::Untouched)?;
415 let aside = aside_path(&parent, base, RESTORE_MARKER, now_micros);
416 rename(data_dir, &aside)
417 .with_context(|| {
418 format!("moving {} aside to {}", data_dir.display(), aside.display())
419 })
420 .map_err(Swap::Untouched)?;
421 Some(aside)
422 }
423 Err(e) if e.kind() == ErrorKind::NotFound => None,
424 Err(e) => {
425 return Err(Swap::Untouched(
426 anyhow!(e).context(format!("reading {}", data_dir.display())),
427 ));
428 }
429 };
430 let Err(e) = rename(staging, data_dir) else {
431 return Ok(moved_aside);
432 };
433 let error = anyhow!(e).context(format!(
434 "moving the restored copy {} into {}",
435 staging.display(),
436 data_dir.display()
437 ));
438 let Some(aside) = moved_aside else {
439 return Err(Swap::Untouched(error));
440 };
441 match rename(&aside, data_dir) {
442 Ok(()) => Err(Swap::Untouched(error)),
443 Err(back) => Err(Swap::Stranded(error.context(format!(
444 "the previous data dir is at {} and could not be moved back ({back}); the restored \
445 copy is at {}",
446 aside.display(),
447 staging.display()
448 )))),
449 }
450}
451
452fn sync_tree(dir: &Path) -> Result<()> {
455 for entry in fs::read_dir(dir).with_context(|| format!("reading {}", dir.display()))? {
456 let entry = entry?;
457 let path = entry.path();
458 let kind = entry.file_type()?;
459 if kind.is_dir() {
460 sync_tree(&path)?;
461 } else if kind.is_file() {
462 fs::File::open(&path)
463 .and_then(|f| f.sync_all())
464 .with_context(|| format!("syncing {}", path.display()))?;
465 }
466 }
467 sync_dir(dir)
468}
469
470fn copy_tree(from: &Path, to: &Path, top: bool) -> Result<()> {
471 for entry in fs::read_dir(from).with_context(|| format!("reading {}", from.display()))? {
472 let entry = entry?;
473 let name = entry.file_name();
474 if top && name.to_str().is_some_and(left_behind) {
475 continue;
476 }
477 let source = entry.path();
478 let target = to.join(&name);
479 let kind = entry.file_type()?;
480 if kind.is_dir() {
481 fs::create_dir(&target).with_context(|| format!("creating {}", target.display()))?;
482 copy_tree(&source, &target, false)?;
483 } else if kind.is_file() {
484 fs::copy(&source, &target)
485 .with_context(|| format!("copying {} to {}", source.display(), target.display()))?;
486 } else if kind.is_symlink() {
487 copy_symlink(&source, &target)?;
488 } else {
489 tracing::warn!("restore skips {}, which is not a file", source.display());
490 }
491 }
492 Ok(())
493}
494
495#[cfg(unix)]
496fn copy_symlink(source: &Path, target: &Path) -> Result<()> {
497 let link = fs::read_link(source).with_context(|| format!("reading {}", source.display()))?;
498 std::os::unix::fs::symlink(&link, target)
499 .with_context(|| format!("linking {} to {}", target.display(), link.display()))
500}
501
502#[cfg(not(unix))]
503fn copy_symlink(source: &Path, _target: &Path) -> Result<()> {
504 tracing::warn!("restore skips the link {}", source.display());
505 Ok(())
506}
507
508fn remove_stale_staging(parent: &Path, prefix: &str, backup: &Path) {
511 let Ok(entries) = fs::read_dir(parent) else {
512 return;
513 };
514 for entry in entries.flatten() {
515 if !entry.file_name().to_string_lossy().starts_with(prefix)
516 || fs::canonicalize(entry.path()).is_ok_and(|p| p == backup)
517 {
518 continue;
519 }
520 if let Err(e) = fs::remove_dir_all(entry.path()) {
521 tracing::warn!(
522 "cannot remove the partial restore {}: {e}",
523 entry.path().display()
524 );
525 }
526 }
527}
528
529fn with_staging_removed(error: anyhow::Error, staging: &Path) -> anyhow::Error {
530 match fs::remove_dir_all(staging) {
531 Ok(()) => error,
532 Err(e) if e.kind() == ErrorKind::NotFound => error,
533 Err(e) => error.context(format!(
534 "also failed to remove the partial restore {}: {e}",
535 staging.display()
536 )),
537 }
538}
539
540fn parent_of(path: &Path) -> Result<PathBuf> {
541 match path.parent() {
542 Some(dir) if !dir.as_os_str().is_empty() => Ok(dir.to_path_buf()),
543 Some(_) => Ok(PathBuf::from(".")),
544 None => bail!("{} has no parent directory", path.display()),
545 }
546}
547
548fn dir_name(path: &Path) -> Result<String> {
549 path.file_name()
550 .map(|n| n.to_string_lossy().into_owned())
551 .ok_or_else(|| anyhow!("{} has no directory name", path.display()))
552}
553
554#[cfg(test)]
555mod tests {
556 use super::*;
557
558 #[test]
559 fn left_behind_names_the_old_devices_files_and_key_temporaries() {
560 for name in LEFT_BEHIND {
561 assert!(left_behind(name), "{name}");
562 }
563 for name in [
564 ".device.key.tmp1",
565 ".store.key.x",
566 &format!("{PLAINTEXT_COPY_PREFIX}abc"),
567 ] {
568 assert!(left_behind(name), "{name}");
569 }
570 for name in [
571 "brain.db",
572 "store.key.wrapped",
573 "transcripts",
574 "brain.indexes",
575 "queue",
576 ] {
577 assert!(!left_behind(name), "{name}");
578 }
579 }
580
581 use crate::keys::{DeviceRecord, Epoch, IdentityKey, create_device_keys};
582 use crate::schema::{Memory, MemoryType};
583 use crate::store::Store;
584
585 const NOW: i64 = 1_793_600_000_000_000;
586
587 struct OldDevice {
588 dir: tempfile::TempDir,
589 tag: IdentityTag,
590 phrase: RecoveryPhrase,
591 memory: Memory,
592 }
593
594 fn open_restored(data_dir: &Path, machine_id: &str) -> SqliteStore {
595 let db = data_dir.join(DB_FILE);
596 if db_file_state(&db).unwrap() != FileState::Encrypted {
597 return SqliteStore::open(&db, machine_id.to_string()).unwrap();
598 }
599 let device = super::super::load_device_keys(data_dir).unwrap().unwrap();
600 let key = super::super::store_key_for(&db, &device).unwrap();
601 SqliteStore::open_with_key(&db, machine_id.to_string(), &key).unwrap()
602 }
603
604 #[cfg(feature = "encryption")]
605 #[test]
606 fn an_encrypted_backup_opens_with_the_phrase_and_comes_back_under_a_new_store_key() {
607 let old = old_device();
608 let old_machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
609 let old_device_keys = super::super::load_device_keys(old.dir.path())
610 .unwrap()
611 .unwrap();
612 {
613 let store =
614 SqliteStore::open(&old.dir.path().join(DB_FILE), old_machine.id.clone()).unwrap();
615 super::super::encrypt_store(&store, old.dir.path(), &old_device_keys).unwrap();
616 }
617 assert!(old.dir.path().join(WRAPPED_STORE_KEY_FILE).exists());
618 let old_store_key =
619 super::super::read_store_key(&old.dir.path().join(STORE_KEY_FILE), &old_device_keys)
620 .unwrap()
621 .unwrap();
622
623 let home = tempfile::tempdir().unwrap();
624 let data_dir = home.path().join(".second-brain");
625 let restored = restore_backup(&RestoreRequest {
626 backup: old.dir.path(),
627 data_dir: &data_dir,
628 phrase: &old.phrase,
629 storage: &KeyStorage::File,
630 now_micros: NOW,
631 })
632 .unwrap();
633
634 let db = data_dir.join(DB_FILE);
635 assert_eq!(db_file_state(&db).unwrap(), FileState::Encrypted);
636 assert!(
637 SqliteStore::open_with_key(&db, restored.machine.id.clone(), &old_store_key).is_err(),
638 "the backup's store key must not open the restored store"
639 );
640 let store = open_restored(&data_dir, &restored.machine.id);
641 assert_eq!(
642 store.get_memory(old.memory.id).unwrap().unwrap().content,
643 old.memory.content
644 );
645 let new_key = super::super::unwrap_store_key_with_phrase(&data_dir, &restored.phrase)
646 .unwrap()
647 .expect("the restored data dir wraps its store key to the new phrase");
648 assert!(SqliteStore::open_with_key(&db, restored.machine.id.clone(), &new_key).is_ok());
649 assert!(
650 super::super::unwrap_store_key_with_phrase(&data_dir, &old.phrase).is_err(),
651 "the old phrase opens no store key of the new identity"
652 );
653 }
654
655 const SEALED_ENTRY: &str = "0000000000000000001-0b5c2f9e-5d0e-4c1a-9a57-0c7f4f1f2a10.sealed";
656
657 fn queued_forget() -> write_queue::Entry {
658 write_queue::Entry {
659 tool: "forget".to_string(),
660 method: "DELETE".to_string(),
661 path: "/v1/memory/m-1".to_string(),
662 query: Some("hard=false&reason=wrong".to_string()),
663 body: None,
664 }
665 }
666
667 fn old_device() -> OldDevice {
670 let dir = tempfile::tempdir().unwrap();
671 let path = dir.path();
672 let machine = MachineIdentity::load_or_create(path).unwrap();
673 let device = create_device_keys(path, &KeyStorage::File).unwrap();
674 let store = SqliteStore::open(&path.join(DB_FILE), machine.id.clone()).unwrap();
675 store.register_machine(&machine).unwrap();
676
677 let epoch0 = IdentityKey::generate().unwrap();
678 let epoch1 = IdentityKey::generate().unwrap();
679 let tag = IdentityTag::migrated(&epoch0.key_id());
680 let epochs = [
681 Epoch {
682 number: 0,
683 key_id: epoch0.key_id(),
684 },
685 Epoch {
686 number: 1,
687 key_id: epoch1.key_id(),
688 },
689 ];
690 let own = machine.id.clone();
691 let envelopes = [
692 wrap(&epoch0, 0, &tag, &device.age_recipient(), Some(own.clone())).unwrap(),
693 wrap(&epoch1, 1, &tag, &device.age_recipient(), Some(own.clone())).unwrap(),
694 ];
695 let row = DeviceRecord {
696 machine_id: own.clone(),
697 identity_tag: tag.as_str().to_string(),
698 version: 1,
699 name: machine.name.clone(),
700 age_recipient: device.age_recipient().to_string(),
701 ssh_public_key: device.ssh_public_key(),
702 signing_public_key: device.verifying_key().to_bytes(),
703 recovery_fingerprints: Vec::new(),
704 ssh_login: None,
705 ssh_port: None,
706 ssh_host_key: None,
707 }
708 .sign(&own, device.signing_key());
709 store
710 .insert_first_device_record(&row, &own, &device.verifying_key())
711 .unwrap();
712 store
713 .put_keys_durably(&tag, &epochs, &envelopes, NOW)
714 .unwrap();
715
716 let phrase = RecoveryPhrase::generate().unwrap();
717 let held = [(epochs[0], &epoch0), (epochs[1], &epoch1)];
718 wrap_for_recovery(&store, &tag, &held, &[phrase.recipient().unwrap()]).unwrap();
719
720 let memory = Memory::new(
721 "the restored store keeps this".to_string(),
722 MemoryType::Semantic,
723 "test".to_string(),
724 String::new(),
725 );
726 store.store_memory(&memory).unwrap();
727 store.record_peer_ack("old-peer", 3, NOW).unwrap();
728 store.pin_peer("old-peer", 2).unwrap();
729 assert_eq!(store.peer_acks().unwrap().len(), 1);
730 drop(store);
731
732 fs::write(path.join("sync-peers"), "someone@old-peer\n").unwrap();
733 fs::write(path.join(".device.key.0123.tmp"), "half-written key").unwrap();
734 fs::write(path.join("api.token"), "old-token").unwrap();
735 fs::write(path.join(DEVICE_PUB_FILE), "age1old\n").unwrap();
736 fs::write(path.join("service.json"), "{\"from\":\"backup\"}").unwrap();
737 fs::create_dir(path.join("queue")).unwrap();
738 fs::write(path.join("queue").join("pending.json"), "{}").unwrap();
739 fs::write(
740 path.join("queue").join(SEALED_ENTRY),
741 queued_forget()
742 .to_sealed_file(&[device.age_recipient()])
743 .unwrap(),
744 )
745 .unwrap();
746 OldDevice {
747 dir,
748 tag,
749 phrase,
750 memory,
751 }
752 }
753
754 fn pins(store: &SqliteStore) -> i64 {
755 store
756 .conn()
757 .query_row("SELECT COUNT(*) FROM peer_pins", [], |r| r.get(0))
758 .unwrap()
759 }
760
761 #[test]
762 fn the_phrase_restores_a_backup_under_a_new_machine_id_and_identity() {
763 let old = old_device();
764 let old_machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
765 let old_key = fs::read(old.dir.path().join(DEVICE_KEY_FILE)).unwrap();
766
767 let home = tempfile::tempdir().unwrap();
768 let data_dir = home.path().join(".second-brain");
769 fs::create_dir(&data_dir).unwrap();
770 let fresh = MachineIdentity::load_or_create(&data_dir).unwrap();
771 SqliteStore::open(&data_dir.join(DB_FILE), fresh.id.clone()).unwrap();
772 fs::write(data_dir.join("service.json"), "{\"from\":\"host\"}").unwrap();
773
774 let typed = RecoveryPhrase::parse(&old.phrase.expose_text()).unwrap();
775 let restored = restore_backup(&RestoreRequest {
776 backup: old.dir.path(),
777 data_dir: &data_dir,
778 phrase: &typed,
779 storage: &KeyStorage::File,
780 now_micros: NOW,
781 })
782 .unwrap();
783
784 let machine = MachineIdentity::load_or_create(&data_dir).unwrap();
785 assert_eq!(machine.id, restored.machine.id);
786 assert_ne!(machine.id, old_machine.id);
787 assert_ne!(machine.id, fresh.id);
788 assert_ne!(fs::read(data_dir.join(DEVICE_KEY_FILE)).unwrap(), old_key);
789 assert!(!data_dir.join("sync-peers").exists());
790 assert!(!data_dir.join(".device.key.0123.tmp").exists());
791 assert!(!data_dir.join("api.token").exists());
792 assert!(!data_dir.join(DEVICE_PUB_FILE).exists());
793 assert_eq!(
794 fs::read_to_string(data_dir.join("service.json")).unwrap(),
795 "{\"from\":\"host\"}"
796 );
797 assert!(data_dir.join("queue").join("pending.json").exists());
798 let sealed = fs::read(data_dir.join("queue").join(SEALED_ENTRY)).unwrap();
799 let device = super::super::load_device_keys(&data_dir).unwrap().unwrap();
800 let opened = write_queue::open(&sealed, Some(device.age_identity())).unwrap();
801 assert_eq!(opened, queued_forget());
802 let aside = restored.moved_aside.clone().unwrap();
803 assert!(aside.join(DB_FILE).exists());
804 assert_eq!(
805 MachineIdentity::load_or_create(&aside).unwrap().id,
806 fresh.id
807 );
808 assert!(
809 old.dir.path().join("sync-peers").exists(),
810 "the backup is untouched"
811 );
812
813 let expected = if cfg!(feature = "encryption") {
814 FileState::Encrypted
815 } else {
816 FileState::Plaintext
817 };
818 assert_eq!(db_file_state(&data_dir.join(DB_FILE)).unwrap(), expected);
819 let store = open_restored(&data_dir, &machine.id);
820 assert_eq!(
821 store.get_memory(old.memory.id).unwrap().unwrap().content,
822 old.memory.content
823 );
824 let row = store.device_record(&machine.id).unwrap().unwrap();
825 assert_eq!(row.current.record.identity_tag, restored.identity.as_str());
826 assert!(restored.identity.as_str().starts_with("f-"));
827 assert_ne!(restored.identity, old.tag);
828 assert_eq!(restored.opened, vec![old.tag.clone()]);
829 assert_eq!(
830 row.current.record.recovery_fingerprints,
831 vec![restored.phrase.fingerprint().unwrap()]
832 );
833
834 assert!(
835 store.peer_acks().unwrap().is_empty(),
836 "old neighbours are cleared"
837 );
838 assert_eq!(pins(&store), 0);
839
840 let device = super::super::load_device_keys(&data_dir).unwrap().unwrap();
841 let mine = store.envelopes_for_machine(&machine.id).unwrap();
842 let old_epochs: Vec<u32> = mine
843 .iter()
844 .filter(|e| e.identity_tag == old.tag)
845 .map(|e| e.epoch.number)
846 .collect();
847 assert_eq!(
848 old_epochs,
849 vec![0, 1],
850 "old epochs stay readable on the new device"
851 );
852 for envelope in &mine {
853 envelope.open(device.age_identity()).unwrap();
854 }
855 let new_epochs = store.key_epochs(&restored.identity).unwrap();
856 assert_eq!(new_epochs.len(), 1);
857 assert_eq!(new_epochs[0].epoch.number, 1);
858
859 let shown = RecoveryPhrase::parse(&restored.phrase.expose_text()).unwrap();
860 let recipients = store.recovery_recipients(&restored.identity).unwrap();
861 assert_eq!(recipients.len(), 1);
862 assert_eq!(
863 recipients[0].to_string(),
864 shown.recipient().unwrap().to_string()
865 );
866 let envelope = store
867 .recovery_envelopes(&shown.recipient().unwrap())
868 .unwrap();
869 assert_eq!(envelope.len(), 3, "the new epoch and both old ones");
870 envelope[0].open(&shown.identity().unwrap()).unwrap();
871 assert!(
872 store
873 .recovery_recipients(&restored.identity)
874 .unwrap()
875 .iter()
876 .all(|r| r.to_string() != old.phrase.recipient().unwrap().to_string()),
877 "the old phrase is not trusted by the new identity"
878 );
879 let leftovers: Vec<_> = fs::read_dir(home.path())
880 .unwrap()
881 .filter_map(|e| e.ok())
882 .filter(|e| e.file_name().to_string_lossy().contains("restoring"))
883 .collect();
884 assert!(leftovers.is_empty());
885 }
886
887 #[test]
888 fn a_second_restore_with_the_new_phrase_opens_every_earlier_identity() {
889 let old = old_device();
890 let first_home = tempfile::tempdir().unwrap();
891 let first_dir = first_home.path().join(".second-brain");
892 let first = restore_backup(&RestoreRequest {
893 backup: old.dir.path(),
894 data_dir: &first_dir,
895 phrase: &old.phrase,
896 storage: &KeyStorage::File,
897 now_micros: NOW,
898 })
899 .unwrap();
900
901 let second_home = tempfile::tempdir().unwrap();
902 let second_dir = second_home.path().join(".second-brain");
903 let second = restore_backup(&RestoreRequest {
904 backup: &first_dir,
905 data_dir: &second_dir,
906 phrase: &first.phrase,
907 storage: &KeyStorage::File,
908 now_micros: NOW,
909 })
910 .unwrap();
911 let opened: BTreeSet<&str> = second.opened.iter().map(IdentityTag::as_str).collect();
912 assert_eq!(
913 opened,
914 BTreeSet::from([old.tag.as_str(), first.identity.as_str()])
915 );
916
917 let store = open_restored(&second_dir, &second.machine.id);
918 let device = super::super::load_device_keys(&second_dir)
919 .unwrap()
920 .unwrap();
921 let mine = store.envelopes_for_machine(&second.machine.id).unwrap();
922 let held = |tag: &IdentityTag| -> Vec<u32> {
923 mine.iter()
924 .filter(|e| &e.identity_tag == tag)
925 .map(|e| {
926 e.open(device.age_identity()).unwrap();
927 e.epoch.number
928 })
929 .collect()
930 };
931 assert_eq!(held(&old.tag), vec![0, 1]);
932 assert_eq!(held(&first.identity), vec![1]);
933 assert_eq!(held(&second.identity), vec![1]);
934 let last = store
935 .recovery_envelopes(&second.phrase.recipient().unwrap())
936 .unwrap();
937 assert_eq!(last.len(), 4, "every epoch reaches the newest phrase");
938 }
939
940 #[test]
941 fn a_restore_from_a_stranded_copy_keeps_that_copy() {
942 let old = old_device();
943 let home = tempfile::tempdir().unwrap();
944 let stranded = home.path().join("..second-brain.restoring-0123");
945 fs::create_dir(&stranded).unwrap();
946 copy_tree(old.dir.path(), &stranded, false).unwrap();
947 restore_backup(&RestoreRequest {
948 backup: &stranded,
949 data_dir: &home.path().join(".second-brain"),
950 phrase: &old.phrase,
951 storage: &KeyStorage::File,
952 now_micros: NOW,
953 })
954 .unwrap();
955 assert!(stranded.join(DB_FILE).exists());
956 }
957
958 #[test]
959 fn a_restore_binds_the_new_device_keys_to_this_hardware_not_the_backups() {
960 use crate::keys::{
961 HardwareCheck, HardwareId, check_hardware_with, read_binding, write_binding,
962 };
963
964 struct Here;
965 impl HardwareSource for Here {
966 fn read(&self, _data_dir: &Path) -> HardwareId {
967 HardwareId::parse("disk:the-new-hardware")
968 }
969 }
970
971 let old = old_device();
972 write_binding(
973 old.dir.path(),
974 &HardwareId::parse("disk:the-backups-hardware"),
975 )
976 .unwrap();
977 let home = tempfile::tempdir().unwrap();
978 let data_dir = home.path().join(".second-brain");
979 let restored = restore_with_hardware(
980 &BackupRestore {
981 backup: old.dir.path(),
982 data_dir: &data_dir,
983 keys: BackupKeys::Phrase(&old.phrase),
984 storage: &KeyStorage::File,
985 now_micros: NOW,
986 },
987 &Here,
988 )
989 .unwrap();
990 assert_eq!(
991 read_binding(&data_dir).unwrap(),
992 Some(HardwareId::parse("disk:the-new-hardware"))
993 );
994 assert_eq!(
995 check_hardware_with(&data_dir, &data_dir, &KeyStorage::File, &Here).unwrap(),
996 HardwareCheck::Bound
997 );
998 assert_eq!(
999 MachineIdentity::load_or_create(&data_dir).unwrap().id,
1000 restored.machine.id
1001 );
1002 }
1003
1004 #[test]
1005 fn a_restore_into_a_missing_data_dir_creates_it() {
1006 let old = old_device();
1007 let home = tempfile::tempdir().unwrap();
1008 let data_dir = home.path().join(".second-brain");
1009 let stale = home.path().join("..second-brain.restoring-0123");
1010 fs::create_dir(&stale).unwrap();
1011 fs::write(stale.join(DB_FILE), "left by a crash").unwrap();
1012 let restored = restore_backup(&RestoreRequest {
1013 backup: old.dir.path(),
1014 data_dir: &data_dir,
1015 phrase: &old.phrase,
1016 storage: &KeyStorage::File,
1017 now_micros: NOW,
1018 })
1019 .unwrap();
1020 assert!(restored.moved_aside.is_none());
1021 assert!(!stale.exists(), "a crashed restore's copy is removed");
1022 assert!(data_dir.join(DB_FILE).exists());
1023 assert!(!data_dir.join("service.json").exists());
1024 }
1025
1026 fn handed_from(old: &OldDevice) -> Vec<HeldEpoch> {
1027 let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1028 let device = super::super::load_device_keys(old.dir.path())
1029 .unwrap()
1030 .unwrap();
1031 let store = SqliteStore::open(&old.dir.path().join(DB_FILE), machine.id).unwrap();
1032 let held = super::super::every_held_epoch(&store, &device).unwrap();
1033 let transit = DeviceKeys::generate().unwrap();
1034 let envelopes = super::super::hand_over(&held, &transit.age_recipient()).unwrap();
1035 super::super::open_handed(&envelopes, &transit).unwrap()
1036 }
1037
1038 #[cfg(feature = "encryption")]
1039 #[test]
1040 fn epochs_a_surviving_device_hands_over_restore_an_encrypted_backup_as_a_new_identity() {
1041 let old = old_device();
1042 let backup = tempfile::tempdir().unwrap();
1043 {
1044 let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1045 let device = super::super::load_device_keys(old.dir.path())
1046 .unwrap()
1047 .unwrap();
1048 let store = SqliteStore::open(&old.dir.path().join(DB_FILE), machine.id).unwrap();
1049 super::super::encrypt_store(&store, old.dir.path(), &device).unwrap();
1050 }
1051 copy_tree(old.dir.path(), backup.path(), false).unwrap();
1052 let held = {
1053 let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1054 let device = super::super::load_device_keys(old.dir.path())
1055 .unwrap()
1056 .unwrap();
1057 let key = super::super::store_key_for(&old.dir.path().join(DB_FILE), &device).unwrap();
1058 let store = SqliteStore::open_with_key(&old.dir.path().join(DB_FILE), machine.id, &key)
1059 .unwrap();
1060 let held = super::super::every_held_epoch(&store, &device).unwrap();
1061 let transit = DeviceKeys::generate().unwrap();
1062 let envelopes = super::super::hand_over(&held, &transit.age_recipient()).unwrap();
1063 super::super::open_handed(&envelopes, &transit).unwrap()
1064 };
1065
1066 let home = tempfile::tempdir().unwrap();
1067 let data_dir = home.path().join(".second-brain");
1068 let restored = restore_backup_with(&BackupRestore {
1069 backup: backup.path(),
1070 data_dir: &data_dir,
1071 keys: BackupKeys::Epochs(&held),
1072 storage: &KeyStorage::File,
1073 now_micros: NOW,
1074 })
1075 .unwrap();
1076
1077 assert_ne!(restored.identity, old.tag);
1078 assert_eq!(restored.opened, vec![old.tag.clone()]);
1079 let store = open_restored(&data_dir, &restored.machine.id);
1080 assert_eq!(
1081 store.get_memory(old.memory.id).unwrap().unwrap().content,
1082 old.memory.content
1083 );
1084 let device = super::super::load_device_keys(&data_dir).unwrap().unwrap();
1085 let kept: Vec<u32> = store
1086 .envelopes_for_machine(&restored.machine.id)
1087 .unwrap()
1088 .iter()
1089 .filter(|e| e.identity_tag == old.tag)
1090 .map(|e| e.epoch.number)
1091 .collect();
1092 assert_eq!(kept, vec![0, 1], "the handed epochs stay decrypt-only");
1093 let opened = super::super::every_held_epoch(&store, &device).unwrap();
1094 assert_eq!(opened.len(), 3, "both old epochs and the new identity's");
1095 let recovery = store
1096 .recovery_envelopes(&restored.phrase.recipient().unwrap())
1097 .unwrap();
1098 assert_eq!(recovery.len(), 3, "the new phrase opens the old epochs too");
1099 }
1100
1101 #[cfg(feature = "encryption")]
1102 #[test]
1103 fn a_surviving_device_restores_onto_itself_with_its_own_past_epochs() {
1104 let old = old_device();
1105 {
1106 let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1107 let device = super::super::load_device_keys(old.dir.path())
1108 .unwrap()
1109 .unwrap();
1110 let store = SqliteStore::open(&old.dir.path().join(DB_FILE), machine.id).unwrap();
1111 super::super::encrypt_store(&store, old.dir.path(), &device).unwrap();
1112 }
1113 let backup = tempfile::tempdir().unwrap();
1114 copy_tree(old.dir.path(), backup.path(), false).unwrap();
1115 let own = super::super::every_held_epoch_in(old.dir.path(), &KeyStorage::File).unwrap();
1116 assert_eq!(own.len(), 2);
1117
1118 let restored = restore_backup_with(&BackupRestore {
1119 backup: backup.path(),
1120 data_dir: old.dir.path(),
1121 keys: BackupKeys::Epochs(&own),
1122 storage: &KeyStorage::File,
1123 now_micros: NOW,
1124 })
1125 .unwrap();
1126
1127 let aside = restored
1128 .moved_aside
1129 .clone()
1130 .expect("its own store moves aside");
1131 assert!(aside.to_string_lossy().contains(".before-restore-"));
1132 assert!(aside.join(DB_FILE).exists());
1133 assert!(aside.join(DEVICE_KEY_FILE).exists());
1134 assert_eq!(restored.opened, vec![old.tag.clone()]);
1135 assert_eq!(
1136 db_file_state(&backup.path().join(DB_FILE)).unwrap(),
1137 FileState::Encrypted,
1138 "the backup opens only through the wrapped store key"
1139 );
1140 let store = open_restored(old.dir.path(), &restored.machine.id);
1141 assert_eq!(
1142 store.get_memory(old.memory.id).unwrap().unwrap().content,
1143 old.memory.content
1144 );
1145 fs::remove_dir_all(&aside).unwrap();
1146 }
1147
1148 #[cfg(feature = "encryption")]
1149 #[test]
1150 fn a_live_backup_of_the_store_and_its_wrapped_key_restores_with_own_epochs() {
1151 let old = old_device();
1152 let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1153 let device = super::super::load_device_keys(old.dir.path())
1154 .unwrap()
1155 .unwrap();
1156 {
1157 let store =
1158 SqliteStore::open(&old.dir.path().join(DB_FILE), machine.id.clone()).unwrap();
1159 super::super::encrypt_store(&store, old.dir.path(), &device).unwrap();
1160 }
1161 let live = open_restored(old.dir.path(), &machine.id);
1162 let backup = tempfile::tempdir().unwrap();
1163 live.vacuum_into(&backup.path().join(DB_FILE)).unwrap();
1164 fs::copy(
1165 old.dir.path().join(WRAPPED_STORE_KEY_FILE),
1166 backup.path().join(WRAPPED_STORE_KEY_FILE),
1167 )
1168 .unwrap();
1169 let own = super::super::every_held_epoch_in(old.dir.path(), &KeyStorage::File).unwrap();
1170
1171 let home = tempfile::tempdir().unwrap();
1172 let data_dir = home.path().join(".second-brain");
1173 let restored = restore_backup_with(&BackupRestore {
1174 backup: backup.path(),
1175 data_dir: &data_dir,
1176 keys: BackupKeys::Epochs(&own),
1177 storage: &KeyStorage::File,
1178 now_micros: NOW,
1179 })
1180 .unwrap();
1181 let store = open_restored(&data_dir, &restored.machine.id);
1182 assert_eq!(store.live_counts().unwrap(), live.live_counts().unwrap());
1183 }
1184
1185 #[cfg(feature = "encryption")]
1186 #[test]
1187 fn handed_epochs_that_do_not_seal_the_backup_change_nothing() {
1188 let old = old_device();
1189 {
1190 let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1191 let device = super::super::load_device_keys(old.dir.path())
1192 .unwrap()
1193 .unwrap();
1194 let store = SqliteStore::open(&old.dir.path().join(DB_FILE), machine.id).unwrap();
1195 super::super::encrypt_store(&store, old.dir.path(), &device).unwrap();
1196 }
1197 let held = handed_from(&old_device());
1198 let home = tempfile::tempdir().unwrap();
1199 let data_dir = home.path().join(".second-brain");
1200 fs::create_dir(&data_dir).unwrap();
1201 let fresh = MachineIdentity::load_or_create(&data_dir).unwrap();
1202
1203 let err = restore_backup_with(&BackupRestore {
1204 backup: old.dir.path(),
1205 data_dir: &data_dir,
1206 keys: BackupKeys::Epochs(&held),
1207 storage: &KeyStorage::File,
1208 now_micros: NOW,
1209 })
1210 .unwrap_err();
1211
1212 assert!(
1213 format!("{err:#}").contains("none of the keys at hand"),
1214 "{err:#}"
1215 );
1216 assert_eq!(
1217 MachineIdentity::load_or_create(&data_dir).unwrap().id,
1218 fresh.id
1219 );
1220 let names: Vec<String> = fs::read_dir(home.path())
1221 .unwrap()
1222 .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
1223 .collect();
1224 assert_eq!(names, vec![".second-brain".to_string()]);
1225 }
1226
1227 #[test]
1228 fn no_handed_epochs_change_nothing() {
1229 let old = old_device();
1230 let home = tempfile::tempdir().unwrap();
1231 let data_dir = home.path().join(".second-brain");
1232 fs::create_dir(&data_dir).unwrap();
1233 let fresh = MachineIdentity::load_or_create(&data_dir).unwrap();
1234
1235 let err = restore_backup_with(&BackupRestore {
1236 backup: old.dir.path(),
1237 data_dir: &data_dir,
1238 keys: BackupKeys::Epochs(&[]),
1239 storage: &KeyStorage::File,
1240 now_micros: NOW,
1241 })
1242 .unwrap_err();
1243
1244 assert!(format!("{err:#}").contains("no key"), "{err:#}");
1245 assert_eq!(
1246 MachineIdentity::load_or_create(&data_dir).unwrap().id,
1247 fresh.id
1248 );
1249 }
1250
1251 #[test]
1252 fn a_wrong_phrase_changes_nothing() {
1253 let old = old_device();
1254 let home = tempfile::tempdir().unwrap();
1255 let data_dir = home.path().join(".second-brain");
1256 fs::create_dir(&data_dir).unwrap();
1257 let fresh = MachineIdentity::load_or_create(&data_dir).unwrap();
1258
1259 let other = RecoveryPhrase::generate().unwrap();
1260 let err = restore_backup(&RestoreRequest {
1261 backup: old.dir.path(),
1262 data_dir: &data_dir,
1263 phrase: &other,
1264 storage: &KeyStorage::File,
1265 now_micros: NOW,
1266 })
1267 .unwrap_err();
1268 assert!(format!("{err:#}").contains("opens no key"), "{err:#}");
1269 assert_eq!(
1270 MachineIdentity::load_or_create(&data_dir).unwrap().id,
1271 fresh.id
1272 );
1273 let names: Vec<String> = fs::read_dir(home.path())
1274 .unwrap()
1275 .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
1276 .collect();
1277 assert_eq!(names, vec![".second-brain".to_string()]);
1278 }
1279
1280 #[test]
1281 fn a_directory_without_a_store_is_not_a_backup() {
1282 let empty = tempfile::tempdir().unwrap();
1283 let home = tempfile::tempdir().unwrap();
1284 let phrase = RecoveryPhrase::generate().unwrap();
1285 let err = restore_backup(&RestoreRequest {
1286 backup: empty.path(),
1287 data_dir: &home.path().join(".second-brain"),
1288 phrase: &phrase,
1289 storage: &KeyStorage::File,
1290 now_micros: NOW,
1291 })
1292 .unwrap_err();
1293 assert!(format!("{err:#}").contains("holds no brain.db"), "{err:#}");
1294 }
1295
1296 fn failing(first: usize, last: usize) -> impl Fn(&Path, &Path) -> io::Result<()> {
1298 let calls = std::cell::Cell::new(0);
1299 move |from, to| {
1300 calls.set(calls.get() + 1);
1301 if (first..=last).contains(&calls.get()) {
1302 return Err(io::Error::other("injected rename failure"));
1303 }
1304 fs::rename(from, to)
1305 }
1306 }
1307
1308 fn dirs_with_marker(home: &Path) -> (PathBuf, PathBuf) {
1309 let data_dir = home.join(".second-brain");
1310 let staging = home.join(".second-brain.restoring-test");
1311 fs::create_dir(&data_dir).unwrap();
1312 fs::write(data_dir.join("marker"), "old").unwrap();
1313 fs::create_dir(&staging).unwrap();
1314 fs::write(staging.join("marker"), "restored").unwrap();
1315 (data_dir, staging)
1316 }
1317
1318 #[test]
1319 fn a_failed_swap_puts_the_old_data_dir_back() {
1320 let home = tempfile::tempdir().unwrap();
1321 let (data_dir, staging) = dirs_with_marker(home.path());
1322 let Err(Swap::Untouched(err)) =
1323 swap_in(&data_dir, &staging, ".second-brain", NOW, failing(2, 2))
1324 else {
1325 panic!("the swap must fail with the data dir back in place");
1326 };
1327 assert!(format!("{err:#}").contains("injected"), "{err:#}");
1328 assert_eq!(fs::read_to_string(data_dir.join("marker")).unwrap(), "old");
1329 assert!(staging.join("marker").exists());
1330 }
1331
1332 #[test]
1333 fn a_swap_that_cannot_move_back_names_both_copies_and_keeps_them() {
1334 let home = tempfile::tempdir().unwrap();
1335 let (data_dir, staging) = dirs_with_marker(home.path());
1336 let Err(Swap::Stranded(err)) =
1337 swap_in(&data_dir, &staging, ".second-brain", NOW, failing(2, 3))
1338 else {
1339 panic!("the swap must report both copies");
1340 };
1341 let shown = format!("{err:#}");
1342 assert!(shown.contains(&staging.display().to_string()), "{shown}");
1343 assert!(shown.contains("before-restore"), "{shown}");
1344 assert!(staging.join("marker").exists());
1345 }
1346}