nodes 0.1.0

Library and cli of a simple node/though keeping 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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use super::toml;
use super::config::Config;
use super::node::Node;
use std::io;
use std::fs;

use std::io::prelude::*;
use std::path::PathBuf;
use std::fs::File;

#[derive(Deserialize, Serialize)]
pub struct StorageState {
    last_id: u64,
}

pub struct Storage<'a> {
    config: &'a Config,
    name: String,
    path: PathBuf,
    state: StorageState
}

#[derive(Debug)]
pub enum LoadStorageError {
    InvalidName,
    NotFound,
    Open(io::Error),
    Read(io::Error),
    Parse(toml::de::Error)
}

impl<'a> Storage<'a> {
    /// Loads the storage for the given stoage path.
    /// Note that the passed path has to be the base path of the storage,
    /// not the storage file itself.
    pub fn load(config: &'a Config, name: &str, path: PathBuf) 
            -> Result<Storage<'a>, LoadStorageError> {
        let mut spath = path.clone();
        spath.push("storage");
        let mut f = match File::open(spath) {
            Ok(f) => f,
            Err(e) => return Err(LoadStorageError::Open(e)),
        };

        let mut s = String::new();
        if let Err(e) = f.read_to_string(&mut s) {
            return Err(LoadStorageError::Read(e));
        }

        let state = match toml::from_str::<StorageState>(&s) {
            Ok(s) => s,
            Err(e) => return Err(LoadStorageError::Parse(e)),
        };

        Ok(Storage { config, name: name.to_string(), path, state })
    }

    /// Returns the next id that would be used for a node.
    /// Does not automatically increase it, see use_id.
    pub fn next_id(&self) -> u64 {
        self.state.last_id + 1
    }

    /// Uses the current next_id, i.e. increases the id counter.
    pub fn use_id(&mut self) {
        self.state.last_id += 1;
    }

    /// Returns the path of this storage
    pub fn path(&self) -> &PathBuf { 
        &self.path
    }

    /// Returns the nodes path
    pub fn nodes_path(&self) -> PathBuf { 
        let mut path = self.path.clone();
        path.push("nodes");
        path
    }

    /// Returns the associated config
    pub fn config(&self) -> &Config {
        self.config
    }

    /// Returns the name of this storage
    pub fn name(&self) -> &str {
        &self.name
    }

    /// Returns a list of all nodes in this storage.
    pub fn nodes(&self) -> Vec<Node> {
        let dir = match fs::read_dir(self.nodes_path()) {
            Ok(a) => a,
            Err(e) => {
                println!("Failed to read nodes dir of storage {}: {}",
                    self.name, e);
                return Vec::new();
            },
        };
        
        let mut nodes = Vec::new();
        for entry in dir {
            let entry = match entry {
                Ok(a) => a,
                Err(e) => {
                    println!("Invalid nodes entry in storage {}: {}", 
                        self.name, e);
                    continue;
                },
            };

            let entry = entry.path();
            if entry.is_dir() {
                continue;
            }

            let id = entry.file_stem()
                .and_then(|f| f.to_str())
                .and_then(|f| f.parse::<u64>().ok());

            match id {
                Some(id) => nodes.push(Node::new(&self, id)),
                None => println!("Invalid node file in {}: {}", 
                    self.name, entry.to_str().unwrap_or("<invalid>")),
            }
        }

        nodes
    }

    // TODO: id inc should probably be compile-time checked
    // should be possible somehow
    pub fn next_node(&self) -> Node {
        Node::new(self, self.next_id())
    }
}

/// RAII drop implementation to save the storages state.
impl<'a> Drop for Storage<'a> {
    fn drop(&mut self) {
        let mut path = self.path.clone();
        path.push("storage");
        let mut f = match File::create(path) {
            Ok(f) => f,
            Err(err) => {
                println!("Failed to create file to write \
                    storage state: {}", err);
                return;
            }
        };
        
        if let Err(err) = f.write_all(toml::to_string(&self.state)
                .expect("Internal error, deserializing state file")
                .as_bytes()) {
            println!("Failed to write initial config file: {}", err);
        }
    }
}