aol 0.3.2

Generic purpose append only log implementation.
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

use among::Among;

use core::fmt::{Debug, Display, Formatter, Result};

/// Errors for append-only file.
#[derive(thiserror::Error)]
pub enum Error {
  /// Missing corrupted append-only log header.
  #[error("missing append-only log header, log may be corrupted")]
  CorruptedHeader,

  /// Snapshot has bad magic.
  #[error("append-only has bad magic text")]
  BadMagicText,
  /// Cannot open append-only because the external magic doesn't match.
  #[error("cannot open append-only because the external magic doesn't match. expected {expected}, found {found}")]
  BadExternalMagic {
    /// Expected external magic.
    expected: u16,
    /// Found external magic.
    found: u16,
  },
  /// Cannot open append-only because the magic doesn't match.
  #[error(
    "cannot open append-only because the magic doesn't match. expected {expected}, found {found}"
  )]
  BadMagic {
    /// Expected magic.
    expected: u16,
    /// Found magic.
    found: u16,
  },
  /// Corrupted append-only file: entry checksum mismatch.
  #[error("entry checksum mismatch")]
  ChecksumMismatch,

  /// Corrupted append-only file: not enough bytes to decode append-only entry.
  #[error("entry data len {len} is greater than the remaining file size {remaining}, append-only file might be corrupted")]
  EntryTooLarge {
    /// Entry data len.
    len: u32,
    /// Remaining file size.
    remaining: u32,
  },
  /// I/O error.
  #[error(transparent)]
  IO(#[from] std::io::Error),
}

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

impl Error {
  /// Create a new `Error` from an I/O error.
  #[inline]
  pub(super) const fn io<A, B>(err: std::io::Error) -> Among<A, B, Self> {
    Among::Right(Self::IO(err))
  }

  #[inline]
  pub(super) const fn checksum_mismatch<A, B>() -> Among<A, B, Self> {
    Among::Right(Self::ChecksumMismatch)
  }

  /// Create a new `Corrupted` error.
  #[inline]
  pub(super) const fn entry_corrupted<A, B>(len: u32, remaining: u32) -> Among<A, B, Self> {
    Among::Right(Self::EntryTooLarge { len, remaining })
  }

  #[inline]
  pub(super) const fn bad_external_magic<A, B>(expected: u16, found: u16) -> Among<A, B, Self> {
    Among::Right(Self::BadExternalMagic { expected, found })
  }

  #[inline]
  pub(super) const fn bad_magic<A, B>(expected: u16, found: u16) -> Among<A, B, Self> {
    Among::Right(Self::BadMagic { expected, found })
  }

  #[inline]
  pub(super) const fn corrupted_header<A, B>() -> Among<A, B, Self> {
    Among::Right(Self::CorruptedHeader)
  }
}

#[cfg(feature = "std")]
#[inline]
pub(super) fn read_only_error() -> std::io::Error {
  std::io::Error::new(std::io::ErrorKind::PermissionDenied, "append log read-only")
}