khive-db 0.10.0

SQLite storage backend: entities, edges, notes, events, FTS5, sqlite-vec vectors.
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::fs::File;
use std::io;

use super::{os, Role};

#[derive(Default)]
pub(super) struct GuardedLedger {
    #[cfg(unix)]
    entries: Vec<GuardedIdentity>,
    // Preserve the Windows process-lifetime file-ID ledger. Unix inode
    // recycling does not justify changing Windows handle/delete semantics.
    #[cfg(windows)]
    entries: Vec<(os::Identity, Role)>,
}

impl GuardedLedger {
    pub(super) fn contains_identity(&self, identity: os::Identity) -> bool {
        #[cfg(unix)]
        {
            self.entries.iter().any(|entry| entry.identity == identity)
        }
        #[cfg(windows)]
        {
            self.entries.iter().any(|(opened, _)| *opened == identity)
        }
    }

    pub(super) fn has_other_role(&self, identity: os::Identity, role: Role) -> bool {
        #[cfg(unix)]
        {
            self.entries
                .iter()
                .any(|entry| entry.identity == identity && entry.role != role)
        }
        #[cfg(windows)]
        {
            self.entries
                .iter()
                .any(|(opened, opened_role)| *opened == identity && *opened_role != role)
        }
    }

    pub(super) fn record(
        &mut self,
        file: &File,
        identity: os::Identity,
        role: Role,
    ) -> io::Result<()> {
        #[cfg(unix)]
        {
            if let Some(entry) = self
                .entries
                .iter_mut()
                .find(|entry| entry.identity == identity && entry.role == role)
            {
                entry.open_handles += 1;
            } else {
                self.entries.push(GuardedIdentity {
                    identity,
                    role,
                    open_handles: 1,
                    anchor: Some(file.try_clone()?),
                });
            }
        }
        #[cfg(windows)]
        {
            let _ = file;
            self.entries.push((identity, role));
        }
        Ok(())
    }

    pub(super) fn release(&mut self, identity: os::Identity, role: Role) {
        #[cfg(unix)]
        if let Some(entry) = self
            .entries
            .iter_mut()
            .find(|entry| entry.identity == identity && entry.role == role)
        {
            entry.open_handles = entry.open_handles.saturating_sub(1);
        }
        #[cfg(windows)]
        let _ = (identity, role);
    }

    pub(super) fn retire_unlinked(&mut self) {
        #[cfg(unix)]
        self.entries.retain(|entry| !entry.can_retire());
    }

    #[cfg(all(test, unix))]
    pub(super) fn is_empty(&self) -> bool {
        self.entries.is_empty()
    }
}

/// Pin an admitted Unix physical object rather than retaining a bare inode
/// that can identify a different object after deletion and inode recycling.
#[cfg(unix)]
struct GuardedIdentity {
    identity: os::Identity,
    role: Role,
    open_handles: usize,
    anchor: Option<File>,
}

#[cfg(unix)]
impl GuardedIdentity {
    fn can_retire(&self) -> bool {
        // Named and renamed objects retain their guarded role after SQLite
        // closes. Metadata failure retains the pin and fails closed.
        self.open_handles == 0
            && os::is_unlinked(self.anchor.as_ref().expect("ledger anchor remains open"))
                .unwrap_or(false)
    }
}

#[cfg(unix)]
impl Drop for GuardedIdentity {
    fn drop(&mut self) {
        if let Some(anchor) = self.anchor.take() {
            // Closing a Unix descriptor must preserve other process-wide
            // locks through the existing deferred-close rule.
            os::close_unlocked(anchor, self.identity);
        }
    }
}