bcode_session 0.0.1-alpha.0

Session lifecycle and attachment management for bcode
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Current-session ownership and relocation primitives.

use bcode_session_models::SessionId;
use std::fs;
use std::path::Path;
use thiserror::Error;

/// Errors produced while coordinating current session ownership and paths.
#[derive(Debug, Error)]
pub enum SessionStorageRecoveryError {
    /// Filesystem inspection or relocation failed.
    #[error(transparent)]
    Io(#[from] std::io::Error),
    /// Current session lease coordination failed.
    #[error(transparent)]
    Lease(#[from] crate::lease::SessionLeaseError),
}

/// Outcome of atomically relocating one session directory.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SessionStorageRelocation {
    /// The source was atomically moved into canonical storage.
    Relocated,
    /// A live owner prevented relocation.
    BlockedByOwner,
    /// The canonical destination exists and was not overwritten.
    DestinationConflict,
}

/// Return whether a session at an explicitly supplied root currently has a live owner.
///
/// # Errors
///
/// Returns an error when lease metadata cannot be inspected.
pub fn session_has_active_owner(
    session_id: SessionId,
    root: &Path,
) -> Result<bool, SessionStorageRecoveryError> {
    crate::lease::active_session_owners(root, session_id)
        .map(|owners| !owners.is_empty())
        .map_err(Into::into)
}

/// Atomically relocate one session after coordinating both source and destination.
///
/// This current-runtime primitive has no knowledge of historical root identities or migration
/// policy. Callers supply both roots and interpret the typed outcome.
///
/// # Errors
///
/// Returns an error when lease coordination or atomic rename fails.
pub fn relocate_session(
    session_id: SessionId,
    source_root: &Path,
    destination_root: &Path,
) -> Result<SessionStorageRelocation, SessionStorageRecoveryError> {
    let source = crate::db::session_dir_path(source_root, session_id);
    let destination = crate::db::session_dir_path(destination_root, session_id);
    if destination.exists() {
        return Ok(SessionStorageRelocation::DestinationConflict);
    }
    let source_maintenance =
        match crate::lease::acquire_session_maintenance_guard(source_root, session_id) {
            Ok(guard) => guard,
            Err(crate::lease::SessionLeaseError::OwnedByOtherDaemon { .. }) => {
                return Ok(SessionStorageRelocation::BlockedByOwner);
            }
            Err(error) => return Err(error.into()),
        };
    let destination_maintenance =
        crate::lease::acquire_session_maintenance_guard(destination_root, session_id)?;
    if destination.exists() {
        return Ok(SessionStorageRelocation::DestinationConflict);
    }
    fs::create_dir_all(destination_root)?;
    fs::rename(source, destination)?;
    drop(destination_maintenance);
    drop(source_maintenance);
    Ok(SessionStorageRelocation::Relocated)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn relocation_moves_once_without_overwriting_a_destination() {
        let state = tempfile::tempdir().expect("state");
        let source_root = state.path().join("source");
        let destination_root = state.path().join("destination");
        let session_id = SessionId::new();
        let source = source_root.join(session_id.to_string());
        let destination = destination_root.join(session_id.to_string());
        fs::create_dir_all(&source).expect("source");
        fs::write(source.join("session.db"), b"fixture").expect("fixture");

        assert_eq!(
            relocate_session(session_id, &source_root, &destination_root).expect("relocate"),
            SessionStorageRelocation::Relocated
        );
        assert_eq!(
            fs::read(destination.join("session.db")).expect("moved"),
            b"fixture"
        );

        fs::create_dir_all(&source).expect("replacement source");
        fs::write(source.join("other"), b"other").expect("other fixture");
        assert_eq!(
            relocate_session(session_id, &source_root, &destination_root).expect("conflict"),
            SessionStorageRelocation::DestinationConflict
        );
        assert!(source.join("other").exists());
    }

    #[test]
    fn relocation_reports_live_source_owner() {
        let state = tempfile::tempdir().expect("state");
        let source_root = state.path().join("source");
        let destination_root = state.path().join("destination");
        let session_id = SessionId::new();
        let source = source_root.join(session_id.to_string());
        fs::create_dir_all(&source).expect("source");
        let _owner = crate::lease::acquire_session_lease(
            &source_root,
            session_id,
            &crate::lease::SessionLeaseOwnerContext::default(),
        )
        .expect("owner");

        assert_eq!(
            relocate_session(session_id, &source_root, &destination_root).expect("blocked"),
            SessionStorageRelocation::BlockedByOwner
        );
        assert!(source.exists());
    }
}