move from error-chain to failure

Author: japaric

.gitignore

@@ -1,2 +1,3 @@
 *.rs.bk
+.#*
 target

Cargo.lock

@@ -7,13 +7,14 @@ keywords = ["parse", "tool", "ARM", "ITM"]
 license = "MIT OR Apache-2.0"
 name = "itm"
 repository = "https://github.com/japaric/itm"
-version = "0.2.1"
+version = "0.3.0"
 
 [dependencies]
 chrono = "^0.4"
 clap = "^2.14.0"
 env_logger = "^0.4.3"
-error-chain = "^0.11.0"
+failure = "0.1.1"
+failure_derive = "0.1.1"
 log = "^0.3.8"
 
 [dev-dependencies]

Cargo.toml

@@ -3,13 +3,13 @@
 extern crate chrono;
 extern crate clap;
 extern crate env_logger;
+extern crate failure;
 extern crate itm;
 #[macro_use]
 extern crate log;
 
 use clap::{App, Arg, ArgMatches};
-use itm::error::{Error, ErrorKind, Result, ResultExt};
-use itm::{packet, Decoder};
+use itm::{packet, Decoder, Error};
 use log::{LogLevelFilter, LogRecord};
 use std::fs::File;
 use std::io::Write;
@@ -33,31 +33,14 @@ fn main() {
         .init()
         .unwrap();
 
-    fn show_backtrace() -> bool {
-        env::var("RUST_BACKTRACE").as_ref().map(|s| &s[..]) == Ok("1")
-    }
-
     if let Err(e) = run() {
-        let stderr = io::stderr();
-        let mut stderr = stderr.lock();
-
-        writeln!(stderr, "{}", e).unwrap();
-
-        for e in e.iter().skip(1) {
-            writeln!(stderr, "caused by: {}", e).unwrap();
-        }
-
-        if show_backtrace() {
-            if let Some(backtrace) = e.backtrace() {
-                writeln!(stderr, "{:?}", backtrace).unwrap();
-            }
-        }
+        eprintln!("{}", e);
 
         process::exit(1)
     }
 }
 
-fn run() -> Result<()> {
+fn run() -> Result<(), failure::Error> {
     let matches = App::new("itmdump")
         .version(concat!(
             env!("CARGO_PKG_VERSION"),
@@ -117,41 +100,39 @@ fn run() -> Result<()> {
                 }
                 _ => (),
             },
-            Err(e @ Error(ErrorKind::UnknownHeader(_), _)) => {
-                // We don't know this header type; warn and continue.
-                debug!("{}", e);
-            }
-            Err(Error(ErrorKind::EofBeforePacket, _)) => {
-                if follow {
-                    // NOTE 10 ms let us achieve 60 FPS in the worst case scenario
-                    thread::sleep(Duration::from_millis(10));
+            Err(fe) => {
+                if let Some(ie) = fe.downcast_ref::<Error>().cloned() {
+                    match ie {
+                        Error::UnknownHeader { byte } => {
+                            // We don't know this header type; warn and continue.
+                            debug!("unknown header byte: {:x}", byte);
+                        }
+                        Error::EofBeforePacket => {
+                            if follow {
+                                // NOTE 10 ms let us achieve 60 FPS in the worst case scenario
+                                thread::sleep(Duration::from_millis(10));
+                            } else {
+                                // !follow and EOF. Exit.
+                                return Ok(());
+                            }
+                        }
+                        _ => return Err(fe.into()),
+                    }
                 } else {
-                    // !follow and EOF. Exit.
-                    return Ok(());
+                    return Err(fe);
                 }
             }
-
-            // FIXME: If in follow mode, we may try to read a packet
-            // but reach the end of the file in the middle. Currently
-            // we'd just return an error and hence exit. When we
-            // receive an error, we've already read and discarded some
-            // data, so we can't just go around this loop again.
-            //
-            // We could make a file following wrapper around `read`
-            // that blocks in a loop retrying the read and sleeping if
-            // there's no data.
-            Err(e) => return Err(e),
         }
     } // end of read loop
 
     // Unreachable.
 }
 
-fn open_read(matches: &ArgMatches) -> Result<Box<io::Read + 'static>> {
+fn open_read(matches: &ArgMatches) -> Result<Box<io::Read + 'static>, io::Error> {
     let path = matches.value_of("file");
     Ok(match path {
         Some(path) => {
-            let f = File::open(path).chain_err(|| format!("Couldn't open source file '{}'", path))?;
+            let f = File::open(path)?;
             Box::new(f) as Box<io::Read + 'static>
         }
         None => Box::new(io::stdin()) as Box<io::Read + 'static>,

src/bin/itmdump.rs

@@ -1,9 +1,12 @@
 //! Parse ITM packets from bytes and streams.
 
-use error::{Error, ErrorKind, Result};
-use packet::{self, Instrumentation, Packet};
 use std::io::{self, Cursor, Read};
 
+use failure;
+
+use packet::{self, Instrumentation, Packet};
+use Error;
+
 /// Parses ITM packets.
 pub struct Decoder<R: Read> {
     inner: R,
@@ -45,13 +48,13 @@ impl<R: Read> Decoder<R> {
 
     /// Read a single packet from the inner `Read`. This will block
     /// for input if no full packet is currently an available.
-    pub fn read_packet(&mut self) -> Result<Packet> {
+    pub fn read_packet(&mut self) -> Result<Packet, failure::Error> {
         let mut header = [0; 1];
         match self.inner.read_exact(&mut header) {
             Err(ref e) if e.kind() == io::ErrorKind::UnexpectedEof => {
-                return Err(Error::from(ErrorKind::EofBeforePacket))
+                return Err(Error::EofBeforePacket.into())
             }
-            Err(e) => return Err(Error::from(e)),
+            Err(e) => return Err(e.into()),
             Ok(_) => (),
         };
         let header = header[0];
@@ -76,9 +79,9 @@ impl<R: Read> Decoder<R> {
                     let buf = &mut ud.payload[0..payload_len];
                     match read_exact_gently(&mut self.inner, buf, self.follow) {
                         Err(ref e) if e.kind() == io::ErrorKind::UnexpectedEof => {
-                            return Err(Error::from(ErrorKind::EofDuringPacket))
+                            return Err(Error::EofDuringPacket.into());
                         }
-                        Err(e) => return Err(Error::from(e)),
+                        Err(e) => return Err(e.into()),
                         Ok(_) => (),
                     };
                 }
@@ -88,15 +91,13 @@ impl<R: Read> Decoder<R> {
                     kind: packet::Kind::Instrumentation(ud),
                 })
             }
-            _ => {
-                return Err(Error::from(ErrorKind::UnknownHeader(header)));
-            }
+            _ => Err(Error::UnknownHeader { byte: header }.into()),
         }
     }
 }
 
 /// Decode a single packet from a slice of bytes.
-pub fn from_slice(s: &[u8]) -> Result<Packet> {
+pub fn from_slice(s: &[u8]) -> Result<Packet, failure::Error> {
     let mut d = Decoder::new(Cursor::new(Vec::from(s)), false);
     d.read_packet()
 }

src/decoder.rs

@@ -81,20 +81,36 @@
 //!
 //! [CoreSight ITM]: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0314h/CAAGGCDH.html
 
-#![allow(renamed_and_removed_lints)]
-#![allow(unused_doc_comments)]
 #![deny(missing_docs)]
 #![deny(warnings)]
 
+extern crate failure;
 #[macro_use]
-extern crate error_chain;
+extern crate failure_derive;
 #[allow(unused_imports)] // No logging yet.
 #[macro_use]
 extern crate log;
 
 pub mod decoder;
 pub use decoder::Decoder;
 
-pub mod error;
-
 pub mod packet;
+
+/// Error type
+#[derive(Clone, Copy, Debug, Fail)]
+pub enum Error {
+    /// end of file before packet
+    #[fail(display = "end of file before packet")]
+    EofBeforePacket,
+
+    /// end of file during packet
+    #[fail(display = "end of file during packet")]
+    EofDuringPacket,
+
+    /// unknown header
+    #[fail(display = "unknown header byte: {:x}", byte)]
+    UnknownHeader {
+        /// unknown header byte
+        byte: u8,
+    },
+}