Skip to main content

pcs/
io.rs

1/* Copyright (c) Fortanix, Inc.
2 *
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
6 */
7
8use std::fs::File;
9use std::io::{BufReader, Write};
10use std::path::{Path, PathBuf};
11
12use serde::de::DeserializeOwned;
13
14use crate::Error;
15
16///Additional parameters to be passed to the IO write related function.
17pub struct WriteOptions {
18    no_overwrite: bool,
19}
20
21///Builds [WriteOptions] instance
22pub struct WriteOptionsBuilder {
23    no_overwrite: bool,
24}
25
26impl WriteOptionsBuilder {
27    /// Instantiate a new [WriteOptionsBuilder] instance.
28    pub fn new() -> Self {
29        Self {
30            no_overwrite: false
31        }
32    }
33
34    ///Prevent the write operation to overwrite existing file.
35    pub fn disallow_overwrite(mut self) -> Self {
36        self.no_overwrite = true;
37        self
38    }
39
40    ///Instantiate the WriteOptions instance based on the current state of the builder.
41    pub fn build(self) -> WriteOptions {
42        WriteOptions {
43            no_overwrite : self.no_overwrite,
44        }
45    }
46}
47
48/// Write the serializable object `obj` into JSON on a given path `dir`/`filename`. See [WriteOptionsBuilder]
49/// to specify the parameters for file writing operations.
50pub fn write_to_file<T: serde::ser::Serialize>(obj: &T, dir: &str, filename: &str, options: WriteOptions) -> Result<Option<PathBuf>, Error> {
51    let path = Path::new(dir);
52    let path = path.join(filename);
53
54    if options.no_overwrite && path.exists() {
55        return Ok(None)
56    }
57
58    write_to_path(&path, obj)?;
59    Ok(Some(path))
60}
61
62fn write_to_path<T: serde::ser::Serialize>(path: &PathBuf, obj: &T) -> Result<(), Error> {
63    let mut fp = File::create(&path)?;
64
65    fp.write_all(&serde_json::ser::to_vec(obj).unwrap())
66        .map_err(|e| Error::IoError(e))
67}
68
69///Function to read a deserializable object from JSON file from a given path `dir`/`filename`.
70pub fn read_from_file<T: DeserializeOwned>(dir: &str, filename: impl AsRef<Path>) -> Result<T, Error> {
71    let path = Path::new(dir);
72    let path = path.join(filename);
73    let file = File::open(path)?;
74    let reader = BufReader::new(file);
75    let obj = serde_json::from_reader(reader)?;
76    Ok(obj)
77}
78
79pub(crate) fn compose_filename(prefix: &str, extension: &str, evaluation_data_number: Option<u64>) -> String {
80    if let Some(evaluation_data_number) = evaluation_data_number {
81        format!("{}-{evaluation_data_number}{}", prefix, extension)
82    } else {
83        format!("{}{}", prefix, extension)
84    }
85}
86
87pub(crate) fn all_files<'a>(input_dir: &str, prefix: impl AsRef<str> + 'a, extension: &'a str) -> impl Iterator<Item = Result<std::fs::DirEntry, Error>> + 'a {
88    // Construct an iterator where if read_dir() returns an error, that is the
89    // first and only item. If it returns success, the directory entries are
90    // the items.
91    let (first, second) = match std::fs::read_dir(input_dir) {
92        Ok(it) => (Some(it), None),
93        Err(e) => (None, Some(Err(e))),
94    };
95    let entries = first.into_iter().flat_map(|it| it).chain(second.into_iter());
96
97    // match filenames that are generated by compose_filename() above
98    entries.filter_map(move |item| {
99            let prefix = prefix.as_ref();
100            match item {
101                Ok(entry) => {
102                    let fname = entry.file_name();
103                    let fname = fname.to_str()?;
104                    if !(fname.starts_with(prefix) && fname.ends_with(extension)) {
105                        return None;
106                    }
107                    if fname.len() != prefix.len() + extension.len() {
108                        let middle = &fname[(prefix.len())..(fname.len() - extension.len())];
109                        if !middle.starts_with("-") {
110                            return None;
111                        }
112                        let _: u64 = middle[1..].parse().ok()?;
113                    }
114                    Some(Ok(entry))
115                },
116                Err(e) => Some(Err(e.into()))
117            }
118        })
119}
120
121#[cfg(test)]
122mod tests {
123    #[cfg(not(target_env = "sgx"))]
124    #[test]
125    fn test_all_files() {
126        use std::{collections::HashSet, ffi::OsString};
127
128        let a: HashSet<_> = Result::unwrap(super::all_files("./tests/data/read-dir-test", "prefix", ".ext").map(|i| i.map(|entry| entry.file_name()) ).collect());
129        let b: HashSet<_> = <_>::into_iter(["prefix-1.ext", "prefix-2.ext", "prefix-3.ext", "prefix.ext"]).map(|i| OsString::from(i)).collect();
130        assert_eq!(a, b);
131    }
132}