zbox 0.3.0

Zbox is a zero-details, privacy-focused embeddable file system.
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
129
130
131
132
133
134
135
136
137
138

use std::fmt::{self, Debug};
use std::sync::{Arc, RwLock};
use std::collections::HashMap;

use error::{Error, Result};
use base::IntoRef;
use volume::VolumeRef;
use super::{Eid, Id, Txid};

/// Cohort action in transaction
#[derive(Debug, Clone, Copy, PartialEq, Deserialize, Serialize)]
pub enum Action {
    New,
    Update,
    Delete,
}

/// Transable trait, be able to do transaction
pub trait Transable: Debug + Id {
    fn commit(&mut self, action: Action, vol: &VolumeRef) -> Result<()>;
    fn complete_commit(&mut self, action: Action);
    fn abort(&mut self, action: Action);
}

pub type TransableRef = Arc<RwLock<Transable + Send + Sync>>;

#[derive(Debug)]
struct Cohort {
    entity: TransableRef,
    action: Action,
}

/// Transaction
pub struct Trans {
    txid: Txid,
    cohorts: HashMap<Eid, Cohort>,
}

impl Trans {
    pub fn new(txid: Txid) -> Self {
        Trans {
            txid,
            cohorts: HashMap::new(),
        }
    }

    // add entity to transaction
    pub fn add_entity(
        &mut self,
        id: &Eid,
        entity: TransableRef,
        action: Action,
    ) {
        let cohort = self.cohorts.entry(id.clone()).or_insert(Cohort {
            entity: entity,
            action,
        });
        match action {
            Action::Update => {}
            _ => cohort.action = action,
        }
    }

    fn finish(&mut self) {
        self.cohorts.clear();
        Txid::reset_current();
    }

    // commit transaction
    pub fn commit(&mut self, vol: &VolumeRef) -> Result<()> {
        debug!(
            "commit tx#{}: entity_cnt: {}",
            self.txid,
            self.cohorts.len()
        );
        //debug!("trans.commit: cohorts: {:#?}", self.cohorts);

        // commit each entity
        for cohort in self.cohorts.values() {
            match cohort.action {
                Action::Delete => {
                    let using = Arc::strong_count(&cohort.entity);
                    if using > 1 {
                        error!(
                            "Cannot delete entity in use (using: ({}), \
                            cohort: {:?})",
                            using,
                            cohort
                        );
                        return Err(Error::InUse);
                    }
                }
                _ => {}
            }

            let mut ent = cohort.entity.write().unwrap();
            ent.commit(cohort.action, &vol)?;
        }

        Ok(())
    }

    // complete commit
    pub fn complete_commit(&mut self) {
        for cohort in self.cohorts.values() {
            let mut ent = cohort.entity.write().unwrap();
            ent.complete_commit(cohort.action);
        }
        self.finish();
    }

    // abort transaction
    pub fn abort(&mut self) {
        debug!("abort tx#{}", self.txid);

        // notify all cohorts in this transaction to abort
        for cohort in self.cohorts.values() {
            let mut ent = cohort.entity.write().unwrap();
            ent.abort(cohort.action);
        }

        self.finish();
    }
}

impl IntoRef for Trans {}

impl Debug for Trans {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("Trans")
            .field("txid", &self.txid)
            .field("cohorts", &self.cohorts)
            .finish()
    }
}

/// Transaction reference type
pub type TransRef = Arc<RwLock<Trans>>;