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
|
//! Filesystem abstraction for various data types
//!
//! All operations return io::Result<()> to indicate errors
//! and functions that have multiple file endpoints will return
//! a folded error list to indicate which ops were successful
//! and which failed.
//!
//! There is also a `From<Vec<?>> for Result<?>` implementation
//! which will return either `Ok(())` or the first error in the list
//! of operations.
use lcc::traits::AutoEncoder;
use std::collections::HashMap;
use std::error::Error;
use std::io::{self, Read, Write};
use std::{
fs::{self, File, OpenOptions as OO}, path::PathBuf,
};
#[derive(Debug)]
pub struct Filesystem {
name: String,
path: String,
root: PathBuf,
}
/// A switching enum to determine what type of file to load
pub enum FileType {
/// A data record file
Record,
/// A MetaDomain file
Metadata,
/// A simple checksum file
Checksum,
}
/// Construct a file ending for a specific match result
macro_rules! file_ending {
($type:expr) => {
match $type {
FileType::Record => "record",
FileType::Metadata => "meta",
_ => "dat",
}
};
}
impl Filesystem {
pub fn create(path: &str, name: &str) -> Filesystem {
let mut buffer = PathBuf::new();
buffer.push(path);
buffer.push(format!("{}.vault", name));
Filesystem {
name: name.to_owned(),
path: path.to_owned(),
root: buffer,
}
}
/// Create required directories
pub fn scaffold(&self) -> Option<()> {
fs::create_dir_all(&self.root).ok()?;
fs::create_dir(&self.root.join("records")).ok()?;
fs::create_dir(&self.root.join("metadata")).ok()?;
fs::create_dir(&self.root.join("checksums")).ok()?;
Some(())
}
/// Load all files of a certain type into a Vec<String>
pub fn fetch<T: AutoEncoder>(&self, types: FileType) -> Result<Vec<T>, Box<Error>> {
Ok(fs::read_dir(match types {
FileType::Record => self.root.join("records"),
FileType::Metadata => self.root.join("metadata"),
_ => self.root.join("."),
})?.into_iter()
.filter_map(|r| r.ok())
.filter(|f| match f.file_type() {
Ok(vf) => vf.is_file(),
_ => false,
})
.map(|de| de.path())
.filter_map(|p| p.into_os_string().into_string().ok())
.filter_map(|s| File::open(s).ok())
.filter_map(|mut f| f.get_string().ok())
.filter_map(|s| T::decode(&s).ok())
.collect())
}
pub fn pull<T: AutoEncoder>(&self, types: FileType, id: &str) -> Result<T, Box<Error>> {
Ok(T::decode(
&File::open(self.root.join(&format!("{}.{}", id, file_ending!(types))))?.get_string()?,
)?)
}
pub fn sync<T>(&self, data: &HashMap<String, T>, types: FileType) -> Result<(), Box<Error>>
where
T: AutoEncoder,
{
data.into_iter()
.map(|(k, v)| (k, v.encode().ok()))
.map(|(k, v)| {
(
match types {
FileType::Record => self.root.join("records"),
FileType::Metadata => self.root.join("metadata"),
_ => self.root.join("."),
}.join(format!("{}.{}", k, file_ending!(types))),
v,
)
})
.filter(|(_, v)| v.is_some())
.map(|(k, v)| (k, v.unwrap()))
.map(|(path, data): (PathBuf, String)| {
(OO::new().create(true).write(true).open(path), data)
})
.filter(|(path, _)| path.is_ok())
.map(|(file, data)| (file.unwrap(), data))
.for_each(|(mut file, data)| {
file.write_all(data.as_bytes())
.expect("Failed to write file!")
});
Ok(())
}
}
/// A utility trait to read the conents from a file in
/// a single line.
pub trait FileToString {
/// Read the file contents into a string without any
/// error handling.
fn get_string(&mut self) -> Result<String, io::Error>;
}
impl FileToString for File {
fn get_string(&mut self) -> Result<String, io::Error> {
let mut s = String::new();
return match self.read_to_string(&mut s) {
Ok(_) => Ok(s),
Err(e) => Err(e),
};
}
}
|
