io_check 0.1.2

Tool for testing read and write split handling.
Documentation 
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

enum Operation {
    Read,
    Write,
}

pub struct DisplayBacktrace<'a> {
    #[cfg_attr(not(feature = "backtrace"), allow(unused))]
    backtrace: &'a Option<Backtrace>,
    #[cfg_attr(not(feature = "backtrace"), allow(unused))]
    operation: Operation
}

impl<'a> DisplayBacktrace<'a> {
    pub fn read(backtrace: &'a Option<Backtrace>) -> Self {
        DisplayBacktrace {
            backtrace,
            operation: Operation::Read,
        }
    }

    pub fn write(backtrace: &'a Option<Backtrace>) -> Self {
        DisplayBacktrace {
            backtrace,
            operation: Operation::Write,
        }
    }
}

#[cfg(feature = "backtrace")]
mod imp {
    use std::fmt;
    use std::panic::AssertUnwindSafe;
    use super::Operation;

    pub use backtrace::Backtrace;

    // safe because the only modification we do is assigning which can not panic
    // we also don't read from it
    pub struct BacktraceStorageMut<'a>(AssertUnwindSafe<&'a mut Option<Backtrace>>);

    impl<'a> BacktraceStorageMut<'a> {
        pub fn from_mut(storage: &'a mut Option<Backtrace>) -> Self {
            BacktraceStorageMut(AssertUnwindSafe(storage))
        }

        #[inline(always)] // remove this useless frame from backtrace
        pub fn capture(&mut self) {
            *(self.0).0 = Some(Backtrace::new_unresolved());
        }
    }

    pub fn resolve(storage: &mut Option<Backtrace>) {
        storage.as_mut().map(|storage| storage.resolve());
    }

    impl<'a> fmt::Display for super::DisplayBacktrace<'a> {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

            match &self.backtrace {
                Some(backtrace) => {
                    let mut culprit = None;
                    let mut symbols = backtrace.frames().iter().flat_map(|frame| frame.symbols());
                    let op_fn_name = match self.operation {
                        Operation::Read => "<io_check::read::TestReader as std::io::Read>::read::",
                        Operation::Write => "<io_check::write::TestWriter as std::io::Write>::write::",
                    };
                    while let Some(symbol) = symbols.next() {
                        let is_test_reader_read = symbol.name().map(|name| name.to_string().starts_with(op_fn_name));
                        if is_test_reader_read == Some(true) {
                            culprit = symbols.next();
                            break;
                        }
                    }

                    if let Some(culprit) = culprit {
                        if let Some(name) = culprit.name() {
                            writeln!(f, "*******\nMost likely culprit in {}", name)?;
                            if let Some(file) = culprit.filename() {
                                write!(f, "    at {}", file.display())?;
                                if let Some(line) = culprit.lineno() {
                                    write!(f, ":{}", line)?;
                                    if let Some(column) = culprit.colno() {
                                        write!(f, ":{}", column)?;
                                    }
                                }
                                writeln!(f)?;
                            }
                            writeln!(f, "*******")?;
                        }

                        if std::env::var("RUST_BACKTRACE").unwrap_or(String::new()) == "1" {
                            write!(f, "backtrace:\n\n{:?}", backtrace)
                        } else {
                            write!(f, "Set RUST_BACKTRACE=1 environment variable to see the full backtrace")
                        }
                    } else {
                        write!(f, "backtrace:\n\n{:?}", backtrace)
                    }
                },
                None => write!(f, "no backtrace found - the problem is most likely unrelated to flaky IO"),
            }
        }
    }

}

#[cfg(not(feature = "backtrace"))]
mod imp {
    use std::panic::AssertUnwindSafe;

    use std::fmt;

    pub enum Backtrace {}

    // Avoids changing variance based on features.
    // It's UnwindSafe because no operation leaves content in inconsistent state
    pub struct BacktraceStorageMut<'a>(AssertUnwindSafe<std::marker::PhantomData<&'a mut ()>>);

    impl<'a> BacktraceStorageMut<'a> {
        pub fn from_mut(_storage: &'a mut Option<Backtrace>) -> Self {
            BacktraceStorageMut(AssertUnwindSafe(Default::default()))
        }

        pub fn capture(&mut self) {
        }
    }

    pub fn resolve(_storage: &mut Option<Backtrace>) {
    }

    impl<'a> fmt::Display for super::DisplayBacktrace<'a> {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            write!(f, "backtrace unavailable - compile with `backtrace` feature to get a backtrace pointing to the location of incorrect IO handling")
        }
    }
}

pub use imp::*;