solrcopy 0.9.2

Command line tool useful for migration, transformations, backup, and restore of documents stored inside cores of Apache Solr
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

#![allow(dead_code)]

use std::{error::Error, fmt};

pub type BoxedResult<T> = Result<T, Box<dyn Error>>;

pub type BoxedError = Result<(), Box<dyn Error>>;

pub(crate) struct Failed {
    details: String,
}

impl Failed {
    pub(crate) fn new(msg: &str) -> Self {
        Self { details: msg.to_string() }
    }

    pub(crate) fn from(msg: String) -> Self {
        Self { details: msg }
    }

    fn say(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.details)
    }
}

impl fmt::Display for Failed {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.say(f)
    }
}

impl fmt::Debug for Failed {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.say(f)
    }
}

impl Error for Failed {
    fn description(&self) -> &str {
        &self.details
    }
}

// region utilities

pub(crate) fn throw<T>(message: String) -> BoxedResult<T> {
    Err(Box::new(Failed::new(&message)))
}

pub(crate) fn failed(message: String) -> impl FnOnce() -> Box<dyn Error> {
    let res: Box<dyn Error> = Box::new(Failed::new(&message));
    move || res
}

pub(crate) fn rethrow<T, E>(failure: E) -> BoxedResult<T>
where
    E: Error + 'static,
{
    Err(Box::new(failure))
}

pub(crate) fn raise<T>(message: &str) -> BoxedResult<T> {
    Err(Box::new(Failed::new(message)))
}

macro_rules! throws {
    ($($arg:tt)*) => {
        Err(Box::new(crate::fails::Failed::from( format!($($arg)*) )))
    };
}

macro_rules! should_fail {
    ($($arg:tt)*) => {{
        let message = format!($($arg)*);
        let res: Box<dyn std::error::Error> = Box::new(crate::fails::Failed::new(&message));
        move || res
    }};
}

// endregion

#[cfg(test)]
mod tests {
    use crate::fails::{raise, throw};
    use pretty_assertions::assert_eq;

    #[test]
    fn check_throw_and_raise() {
        let failure = throw::<usize>("fail".to_string());
        assert_eq!(failure.is_ok(), false);

        // TODO revamp error handling results types
        // let failerr = failure.err().unwrap();
        // assert_eq!(rethrow(failerr).is_ok(), false);

        assert_eq!(raise::<usize>("fail").is_ok(), false);
    }
}