imag/lib/entry/libimagentryref/src/reference.rs

568 lines
18 KiB
Rust
Raw Normal View History

//
// imag - the personal information management suite for the commandline
// Copyright (C) 2015-2019 Matthias Beyer <mail@beyermatthias.de> and contributors
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version
// 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
use std::collections::BTreeMap;
use std::path::Path;
2016-06-09 17:34:25 +00:00
use std::path::PathBuf;
use std::ops::Deref;
2016-06-09 17:34:25 +00:00
2018-01-08 22:34:13 +00:00
use libimagentryutil::isa::Is;
use libimagentryutil::isa::IsKindHeaderPathProvider;
use libimagerror::errors::ErrorMsg as EM;
2016-06-09 17:34:25 +00:00
use toml::Value;
use toml::map::Map;
2018-02-13 20:11:45 +00:00
use toml_query::read::TomlValueReadExt;
use toml_query::read::TomlValueReadTypeExt;
use toml_query::read::Partial;
use toml_query::delete::TomlValueDeleteExt;
use toml_query::insert::TomlValueInsertExt;
use failure::Fallible as Result;
use failure::Error;
use failure::err_msg;
use failure::ResultExt;
2016-06-14 09:05:38 +00:00
use crate::hasher::Hasher;
2016-06-09 17:34:25 +00:00
/// A configuration of "basepath name" -> "basepath path" mappings
///
/// Should be deserializeable from the configuration file right away, because we expect a
/// configuration like this in the config file:
///
/// ```toml
/// [ref.basepathes]
/// music = "/home/alice/music"
/// documents = "/home/alice/doc"
/// ```
///
/// for example.
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Config(BTreeMap<String, PathBuf>);
2016-06-09 17:34:25 +00:00
impl Config {
pub fn new(map: BTreeMap<String, PathBuf>) -> Self {
Config(map)
}
}
2018-01-08 22:34:13 +00:00
impl Deref for Config {
type Target = BTreeMap<String, PathBuf>;
2017-08-27 18:38:26 +00:00
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<'a> Partial<'a> for Config {
const LOCATION: &'static str = "ref.basepathes";
type Output = Self;
}
provide_kindflag_path!(pub IsRef, "ref.is_ref");
/// Fassade module
///
/// This module is necessary to build a generic fassade around the "entry with a (default) hasher to
/// represent the entry as a ref".
///
/// The module is for code-structuring only, all types in the module are exported publicly in the
/// supermodule.
pub mod fassade {
use std::marker::PhantomData;
2016-06-14 09:08:58 +00:00
use libimagstore::store::Entry;
use libimagentryutil::isa::Is;
use failure::Fallible as Result;
use failure::ResultExt;
use failure::Error;
use crate::hasher::sha1::Sha1Hasher;
use crate::hasher::Hasher;
use super::IsRef;
pub trait RefFassade {
fn is_ref(&self) -> Result<bool>;
fn as_ref_with_hasher<H: Hasher>(&self) -> RefWithHasher<H>;
fn as_ref_with_hasher_mut<H: Hasher>(&mut self) -> MutRefWithHasher<H>;
2016-06-14 09:09:19 +00:00
}
impl RefFassade for Entry {
/// Check whether the underlying object is actually a ref
fn is_ref(&self) -> Result<bool> {
self.is::<IsRef>().context("Failed to check is-ref flag").map_err(Error::from)
}
fn as_ref_with_hasher<H: Hasher>(&self) -> RefWithHasher<H> {
RefWithHasher::new(self)
}
fn as_ref_with_hasher_mut<H: Hasher>(&mut self) -> MutRefWithHasher<H> {
MutRefWithHasher::new(self)
}
2016-06-09 17:34:25 +00:00
}
pub struct RefWithHasher<'a, H: Hasher = Sha1Hasher>(pub(crate) &'a Entry, PhantomData<H>);
impl<'a, H> RefWithHasher<'a, H>
where H: Hasher
{
fn new(entry: &'a Entry) -> Self {
RefWithHasher(entry, PhantomData)
}
2016-06-09 17:34:25 +00:00
}
pub struct MutRefWithHasher<'a, H: Hasher = Sha1Hasher>(pub(crate) &'a mut Entry, PhantomData<H>);
impl<'a, H> MutRefWithHasher<'a, H>
where H: Hasher
{
fn new(entry: &'a mut Entry) -> Self {
MutRefWithHasher(entry, PhantomData)
}
}
2018-02-13 20:11:45 +00:00
}
pub use self::fassade::*;
2016-06-24 15:39:58 +00:00
pub trait Ref {
/// Check whether the underlying object is actually a ref
fn is_ref(&self) -> Result<bool>;
fn get_path(&self, config: &Config) -> Result<PathBuf>;
fn get_path_with_basepath_setting<B>(&self, config: &Config, base: B) -> Result<PathBuf>
where B: AsRef<str>;
fn get_relative_path(&self) -> Result<PathBuf>;
/// Get the stored hash.
fn get_hash(&self) -> Result<&str>;
/// Check whether the referenced file still matches its hash
fn hash_valid(&self, config: &Config) -> Result<bool>;
}
impl<'a, H: Hasher> Ref for RefWithHasher<'a, H> {
2016-06-24 15:39:58 +00:00
2018-02-13 20:11:45 +00:00
/// Check whether the underlying object is actually a ref
fn is_ref(&self) -> Result<bool> {
self.0.is::<IsRef>().context("Failed to check is-ref flag").map_err(Error::from)
2016-06-09 17:34:25 +00:00
}
2018-02-13 21:37:22 +00:00
fn get_hash(&self) -> Result<&str> {
let header_path = format!("ref.hash.{}", H::NAME);
self.0
.get_header()
.read(&header_path)
.context(format_err!("Failed to read header at '{}'", header_path))
.map_err(Error::from)?
.ok_or_else(|| {
Error::from(EM::EntryHeaderFieldMissing("ref.hash.<hash>"))
})
.and_then(|v| {
v.as_str().ok_or_else(|| {
Error::from(EM::EntryHeaderTypeError2("ref.hash.<hash>", "string"))
})
})
2016-06-09 17:34:25 +00:00
}
/// Get the path of the actual file
fn get_path(&self, config: &Config) -> Result<PathBuf> {
let basepath_name = self.0
.get_header()
.read_string("ref.basepath")?
.ok_or_else(|| Error::from(EM::EntryHeaderFieldMissing("ref.basepath")))?;
self.get_path_with_basepath_setting(config, basepath_name)
}
fn get_path_with_basepath_setting<B>(&self, config: &Config, base: B)
-> Result<PathBuf>
where B: AsRef<str>
{
let relpath = self.0
.get_header()
.read_string("ref.relpath")?
.map(PathBuf::from)
.ok_or_else(|| Error::from(EM::EntryHeaderFieldMissing("ref.relpath")))?;
get_file_path(config, base.as_ref(), relpath)
}
/// Get the relative path, relative to the configured basepath
fn get_relative_path(&self) -> Result<PathBuf> {
self.0
.get_header()
.read("ref.relpath")
.context("Failed to read header at 'ref.relpath'")?
.ok_or_else(|| Error::from(EM::EntryHeaderFieldMissing("ref.relpath")))
.and_then(|v| {
v.as_str()
.ok_or_else(|| EM::EntryHeaderTypeError2("ref.relpath", "string"))
.map_err(Error::from)
})
2018-02-13 21:37:22 +00:00
.map(PathBuf::from)
2016-06-09 17:34:25 +00:00
}
fn hash_valid(&self, config: &Config) -> Result<bool> {
let ref_header = self.0
.get_header()
.read("ref")
.context("Failed to read header at 'ref'")?
.ok_or_else(|| err_msg("Header missing at 'ref'"))?;
let basepath_name = ref_header
.read("basepath")
.context("Failed to read header at 'ref.basepath'")?
.ok_or_else(|| err_msg("Header missing at 'ref.basepath'"))?
.as_str()
.ok_or_else(|| Error::from(EM::EntryHeaderTypeError2("ref.hash.<hash>", "string")))?;
let path = ref_header
.read("relpath")
.context("Failed to read header at 'ref.relpath'")?
.ok_or_else(|| err_msg("Header missing at 'ref.relpath'"))?
.as_str()
2018-02-13 21:37:22 +00:00
.map(PathBuf::from)
.ok_or_else(|| Error::from(EM::EntryHeaderTypeError2("ref.hash.<hash>", "string")))?;
let file_path = get_file_path(config, basepath_name.as_ref(), &path)?;
ref_header
.read(H::NAME)
.context(format_err!("Failed to read header at 'ref.{}'", H::NAME))?
.ok_or_else(|| format_err!("Header missing at 'ref.{}'", H::NAME))
.and_then(|v| {
v.as_str().ok_or_else(|| {
Error::from(EM::EntryHeaderTypeError2("ref.hash.<hash>", "string"))
})
})
.and_then(|hash| H::hash(file_path).map(|h| h == hash))
2016-07-14 18:37:32 +00:00
}
}
pub trait MutRef {
fn remove_ref(&mut self) -> Result<()>;
/// Make a ref out of a normal (non-ref) entry.
///
/// If the entry is already a ref, this fails if `force` is false
fn make_ref<P, Coll>(&mut self, path: P, basepath_name: Coll, config: &Config, force: bool)
-> Result<()>
where P: AsRef<Path>,
Coll: AsRef<str>;
}
impl<'a, H> MutRef for MutRefWithHasher<'a, H>
where H: Hasher
{
fn remove_ref(&mut self) -> Result<()> {
debug!("Removing 'ref' header section");
{
let header = self.0.get_header_mut();
trace!("header = {:?}", header);
let _ = header.delete("ref.relpath").context("Removing ref.relpath")?;
if let Some(hash_tbl) = header.read_mut("ref.hash")? {
match hash_tbl {
Value::Table(ref mut tbl) => *tbl = Map::new(),
_ => {
// should not happen
}
}
}
let _ = header.delete("ref.hash").context("Removing ref.hash")?;
let _ = header.delete("ref.basepath").context("Removing ref.basepath")?;
}
debug!("Removing 'ref' header marker");
self.0.remove_isflag::<IsRef>().context("Removing ref")?;
let _ = self.0
.get_header_mut()
.delete("ref")
.context("Removing ref")?;
trace!("header = {:?}", self.0.get_header());
Ok(())
}
/// Make a ref out of a normal (non-ref) entry.
///
/// `path` is the path to refer to,
///
/// # Warning
///
/// If the entry is already a ref, this fails if `force` is false
///
fn make_ref<P, Coll>(&mut self, path: P, basepath_name: Coll, config: &Config, force: bool)
-> Result<()>
where P: AsRef<Path>,
Coll: AsRef<str>
{
trace!("Making ref out of {:?}", self.0);
trace!("Making ref with basepath name {:?}", basepath_name.as_ref());
trace!("Making ref with config {:?}", config);
trace!("Making ref forced = {}", force);
if self.0.get_header().read("ref.is_ref")?.is_some() && !force {
debug!("Entry is already a Ref!");
let _ = Err(err_msg("Entry is already a reference")).context("Making ref out of entry")?;
}
let file_path = get_file_path(config, basepath_name.as_ref(), &path)?;
if !file_path.exists() {
let msg = format_err!("File '{:?}' does not exist", file_path);
let _ = Err(msg).context("Making ref out of entry")?;
}
debug!("Entry hashing = {}", file_path.display());
let _ = H::hash(&file_path)
.and_then(|hash| {
trace!("hash = {}", hash);
// stripping the prefix of "path"
let prefix = get_basepath(basepath_name.as_ref(), config)?;
trace!("Stripping = {}", prefix.display());
let relpath = path.as_ref().strip_prefix(prefix)?;
trace!("Using relpath = {} to make header section", relpath.display());
make_header_section(hash, H::NAME, relpath, basepath_name)
})
.and_then(|h| self.0.get_header_mut().insert("ref", h)
.context("Failed to insert 'ref' in header")
.map_err(Error::from))
.and_then(|_| self.0.set_isflag::<IsRef>())
.context("Making ref out of entry")?;
debug!("Setting is-ref flag");
self.0
.set_isflag::<IsRef>()
.context("Setting ref-flag")
.map_err(Error::from)
.map(|_| ())
}
}
/// Create a new header section for a "ref".
///
/// # Warning
///
/// The `relpath` _must_ be relative to the configured path for that basepath.
pub(crate) fn make_header_section<P, C, H>(hash: String, hashname: H, relpath: P, basepath: C)
-> Result<Value>
where P: AsRef<Path>,
C: AsRef<str>,
H: AsRef<str>,
{
let mut header_section = Value::Table(Map::new());
{
let relpath = relpath
.as_ref()
.to_str()
.map(String::from)
.ok_or_else(|| {
let msg = format_err!("UTF Error in '{:?}'", relpath.as_ref());
Error::from(msg)
})?;
let _ = header_section.insert("relpath", Value::String(relpath))?;
}
{
let mut hash_table = Value::Table(Map::new());
let _ = hash_table.insert(hashname.as_ref(), Value::String(hash))?;
let _ = header_section.insert("hash", hash_table)?;
}
let _ = header_section.insert("basepath", Value::String(String::from(basepath.as_ref())));
Ok(header_section)
}
fn get_basepath<'a, Coll: AsRef<str>>(basepath_name: Coll, config: &'a Config) -> Result<&'a PathBuf> {
config.get(basepath_name.as_ref())
.ok_or_else(|| format_err!("basepath {} seems not to exist in config",
basepath_name.as_ref()))
.map_err(Error::from)
}
fn get_file_path<P>(config: &Config, basepath_name: &str, path: P) -> Result<PathBuf>
where P: AsRef<Path>
{
config
.get(basepath_name)
.map(PathBuf::clone)
.ok_or_else(|| {
format_err!("Configuration missing for basepath: '{}'", basepath_name)
})
.context("Making ref out of entry")
.map_err(Error::from)
.map(|p| {
let filepath = p.join(&path);
trace!("Found filepath: {:?}", filepath.display());
filepath
})
}
#[cfg(test)]
mod test {
use std::path::PathBuf;
use libimagstore::store::Store;
use libimagstore::store::Entry;
use super::*;
use crate::hasher::Hasher;
fn setup_logging() {
let _ = ::env_logger::try_init();
}
pub fn get_store() -> Store {
Store::new_inmemory(PathBuf::from("/"), &None).unwrap()
}
struct TestHasher;
impl Hasher for TestHasher {
const NAME: &'static str = "Testhasher";
fn hash<P: AsRef<Path>>(path: P) -> Result<String> {
path.as_ref()
.to_str()
.map(String::from)
.ok_or_else(|| Error::from(err_msg("Failed to create test hash")))
}
}
#[test]
fn test_isref() {
setup_logging();
let store = get_store();
let entry = store.retrieve(PathBuf::from("test_isref")).unwrap();
assert!(!entry.is_ref().unwrap());
}
#[test]
fn test_makeref() {
setup_logging();
let store = get_store();
let mut entry = store.retrieve(PathBuf::from("test_makeref")).unwrap();
let file = PathBuf::from("/tmp"); // has to exist
let basepath_name = "some_basepath";
let config = Config({
let mut c = BTreeMap::new();
c.insert(String::from("some_basepath"), PathBuf::from("/"));
c
});
let r = entry.as_ref_with_hasher_mut::<TestHasher>().make_ref(file, basepath_name, &config, false);
assert!(r.is_ok());
}
#[test]
fn test_makeref_isref() {
setup_logging();
let store = get_store();
let mut entry = store.retrieve(PathBuf::from("test_makeref_isref")).unwrap();
let file = PathBuf::from("/tmp"); // has to exists
let basepath_name = "some_basepath";
let config = Config({
let mut c = BTreeMap::new();
c.insert(String::from("some_basepath"), PathBuf::from("/"));
c
});
let res = entry.as_ref_with_hasher_mut::<TestHasher>().make_ref(file, basepath_name, &config, false);
assert!(res.is_ok(), "Expected to be ok: {:?}", res);
assert!(entry.as_ref_with_hasher::<TestHasher>().is_ref().unwrap());
}
#[test]
fn test_makeref_is_ref_with_testhash() {
setup_logging();
let store = get_store();
let mut entry = store.retrieve(PathBuf::from("test_makeref_is_ref_with_testhash")).unwrap();
let file = PathBuf::from("/tmp"); // has to exist
let basepath_name = "some_basepath";
let config = Config({
let mut c = BTreeMap::new();
c.insert(String::from("some_basepath"), PathBuf::from("/"));
c
});
assert!(entry.as_ref_with_hasher_mut::<TestHasher>().make_ref(file, basepath_name, &config, false).is_ok());
let check_isstr = |entry: &Entry, location, shouldbe| {
let var = entry.get_header().read(location);
assert!(var.is_ok(), "{} is not Ok(_): {:?}", location, var);
let var = var.unwrap();
assert!(var.is_some(), "{} is not Some(_): {:?}", location, var);
let var = var.unwrap().as_str();
assert!(var.is_some(), "{} is not String: {:?}", location, var);
assert_eq!(var.unwrap(), shouldbe, "{} is not == {}", location, shouldbe);
};
check_isstr(&entry, "ref.relpath", "tmp");
check_isstr(&entry, "ref.hash.Testhasher", "/tmp"); // TestHasher hashes by returning the path itself
check_isstr(&entry, "ref.basepath", "some_basepath");
}
#[test]
fn test_makeref_remref() {
setup_logging();
let store = get_store();
let mut entry = store.retrieve(PathBuf::from("test_makeref_remref")).unwrap();
let file = PathBuf::from("/"); // has to exist
let basepath_name = "some_basepath";
let config = Config({
let mut c = BTreeMap::new();
c.insert(String::from("some_basepath"), PathBuf::from("/"));
c
});
assert!(entry.as_ref_with_hasher_mut::<TestHasher>().make_ref(file, basepath_name, &config, false).is_ok());
assert!(entry.as_ref_with_hasher::<TestHasher>().is_ref().unwrap());
let res = entry.as_ref_with_hasher_mut::<TestHasher>().remove_ref();
assert!(res.is_ok(), "Expected to be ok: {:?}", res);
assert!(!entry.as_ref_with_hasher::<TestHasher>().is_ref().unwrap());
}
2016-07-14 18:37:32 +00:00
}