Struct quickcfg::FileSystem

pub struct FileSystem<'a> { /* private fields */ }

Helper and tracker of any filesystem modifications.

Implementations

impl<'a> FileSystem<'a>

pub fn new( opts: &'a Opts, state_dir: &Path, allocator: &'a UnitAllocator, data: &'a Data ) -> FileSystem<'a>

Create new, thread-safe file utilities.

pub fn validate(self) -> Result<(), Error>

Validate that we haven’t created any conflicting files. Logs details and errors in case duplicates are registered.

pub fn file_dependency(&self, path: &Path) -> Result<Dependency, Error>

Access or allocate a file dependency of the given path.

pub fn dir_dependency(&self, path: &Path) -> Result<Dependency, Error>

Access or allocate a directory dependency of the given path.

pub fn symlink( &self, path: &Path, link: PathBuf, meta: Option<&Metadata> ) -> Result<Option<SystemUnit>, Error>

Try to create a symlink.

pub fn copy_file( &self, from: &Path, from_meta: Metadata, to: &Path, to_meta: Option<&Metadata>, template: bool ) -> Result<Option<SystemUnit>, Error>

Optionally set up if we should copy a file.

This is true if:

• The destination file does not exist.
• The destination file has a modified timestamp less than the source file.

pub fn create_dir_all(&self, dir: &Path) -> Result<Vec<SystemUnit>, Error>

Recursively set up units with dependencies to create the given directories.

pub fn state_path(&self, id: &str) -> PathBuf

Get the state path for the given ID.

pub fn try_open_meta(p: &Path) -> Result<Option<Metadata>, Error>

Try to open metadata, unless the file does not exist.

If the file does not exist, returns None.

pub fn should_create_dir( path: &Path, meta: Option<&Metadata> ) -> Result<bool, Error>

Test if we should create the destination directory.

pub fn path_relative_from(path: &Path, base: &Path) -> Option<PathBuf>

Construct a relative path from a provided base directory path to the provided path

use quickcfg::FileSystem;
use std::path::PathBuf;

let baz: PathBuf = "/foo/bar/baz".into();
let bar: PathBuf = "/foo/bar".into();
let quux: PathBuf = "/foo/bar/quux".into();
assert_eq!(FileSystem::path_relative_from(&bar, &baz), Some("../".into()));
assert_eq!(FileSystem::path_relative_from(&baz, &bar), Some("baz".into()));
assert_eq!(FileSystem::path_relative_from(&quux, &baz), Some("../quux".into()));
assert_eq!(FileSystem::path_relative_from(&baz, &quux), Some("../baz".into()));
assert_eq!(FileSystem::path_relative_from(&bar, &quux), Some("../".into()));

pub fn touch(path: &Path, timestamp: &SystemTime) -> Result<(), Error>

Update timestamps for the given path.