imdl 0.1.14

📦 A 40' shipping container for the internet
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

use crate::common::*;

#[derive(Debug)]
pub(crate) enum FileError {
  Io(io::Error),
  Missing,
  Directory,
  Surfeit(Bytes),
  Dearth(Bytes),
  Md5 {
    expected: Md5Digest,
    actual: Md5Digest,
  },
}

impl FileError {
  pub(crate) fn verify(
    path: &Path,
    expected_length: Bytes,
    expected_md5: Option<Md5Digest>,
  ) -> Result<(), FileError> {
    let metadata = match path.metadata() {
      Ok(metadata) => metadata,
      Err(error) => {
        return Err(if error.kind() == io::ErrorKind::NotFound {
          FileError::Missing
        } else {
          FileError::Io(error)
        })
      }
    };

    if metadata.is_dir() {
      return Err(FileError::Directory);
    }

    let actual = Bytes(metadata.len());

    let difference = actual.absolute_difference(expected_length);

    if actual > expected_length {
      return Err(FileError::Surfeit(difference));
    }

    if actual < expected_length {
      return Err(FileError::Dearth(difference));
    }

    if let Some(expected) = expected_md5 {
      let mut reader = File::open(path)?;
      let mut context = md5::Context::new();
      io::copy(&mut reader, &mut context)?;
      let actual = context.compute().into();

      if actual != expected {
        return Err(FileError::Md5 { actual, expected });
      }
    }

    Ok(())
  }
}

impl From<io::Error> for FileError {
  fn from(io_error: io::Error) -> Self {
    Self::Io(io_error)
  }
}

impl Print for FileError {
  fn print(&self, stream: &mut OutputStream) -> io::Result<()> {
    let style = stream.style();

    if let Self::Md5 { actual, expected } = self {
      write!(
        stream,
        "MD5 checksum mismatch: {} (expected {})",
        style.error().paint(actual.to_string()),
        style.good().paint(expected.to_string()),
      )?;

      return Ok(());
    }

    match self {
      Self::Io(io_error) => write!(stream, "{io_error}")?,
      Self::Missing => write!(stream, "File missing")?,
      Self::Directory => write!(stream, "Expected file but found directory")?,
      Self::Surfeit(difference) => write!(stream, "{difference} too long")?,
      Self::Dearth(difference) => write!(stream, "{difference} too short")?,
      Self::Md5 { .. } => {
        return Err(io::Error::new(
          io::ErrorKind::Other,
          Error::internal("Reached unreachable branch").to_string(),
        ))
      }
    }

    Ok(())
  }
}