weavatrix-worktree 0.2.1

Bounded, crash-recoverable multi-file worktree edits for source refactoring
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use crate::{
    error::{TransactionPhase, WorktreeError, WorktreeErrorCode},
    journal::{FinishOutcome, JournalRecord},
};

use super::{
    PreparedTransaction,
    stage::cleanup_staged,
    util::{fs_error, journal_error},
    verify::{verify_artifact, verify_target},
};

pub(crate) fn rollback_committed(
    transaction: &mut PreparedTransaction,
    committed: &[usize],
) -> Result<(), WorktreeError> {
    for &index in committed.iter().rev() {
        rollback_one(transaction, index)?;
    }
    transaction
        .journal
        .append(&JournalRecord::Finished {
            outcome: FinishOutcome::RolledBack,
        })
        .map_err(|error| {
            journal_error(
                TransactionPhase::Rollback,
                "failed to record completed rollback",
                error,
            )
            .requiring_recovery()
        })?;
    cleanup_staged(&transaction.files)?;
    transaction.control.remove_journal().map_err(|error| {
        WorktreeError::with_source(
            WorktreeErrorCode::RecoveryRequired,
            TransactionPhase::Cleanup,
            "rollback succeeded but journal cleanup failed",
            error,
        )
        .requiring_recovery()
    })
}

fn rollback_one(transaction: &mut PreparedTransaction, index: usize) -> Result<(), WorktreeError> {
    let file = &transaction.files[index];
    verify_target(
        &file.access,
        file.new_hash,
        None,
        transaction.options.limits.max_output_bytes_per_file,
        file.original_index,
        TransactionPhase::Rollback,
    )
    .map_err(|error| recovery_error(&error))?;
    verify_artifact(
        &file.access,
        &file.backup_name,
        file.old_hash,
        transaction.options.limits.max_source_bytes_per_file,
        file.original_index,
        TransactionPhase::Rollback,
    )?;
    transaction
        .journal
        .append(&JournalRecord::RollbackIntent {
            index: file.stable_index,
        })
        .map_err(|error| {
            journal_error(
                TransactionPhase::Rollback,
                "failed to synchronize rollback intent",
                error,
            )
            .requiring_recovery()
        })?;
    file.access
        .rename_from(&file.backup_name)
        .and_then(|()| file.access.sync_parent())
        .map_err(|error| {
            fs_error(
                TransactionPhase::Rollback,
                file.access.path(),
                file.original_index,
                "failed to restore a backup",
                error,
            )
            .requiring_recovery()
        })?;
    transaction
        .journal
        .append(&JournalRecord::RolledBack {
            index: file.stable_index,
        })
        .map_err(|error| {
            journal_error(
                TransactionPhase::Rollback,
                "failed to record restored target",
                error,
            )
            .requiring_recovery()
        })?;
    Ok(())
}

fn recovery_error(error: &WorktreeError) -> WorktreeError {
    WorktreeError::new(
        WorktreeErrorCode::RollbackFailed,
        TransactionPhase::Rollback,
        error.to_string(),
    )
    .requiring_recovery()
}