manifile 0.0.0

Generic purpose append only manifest file 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
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

#[cfg(feature = "std")]
use std::collections::HashSet;

#[cfg(not(feature = "std"))]
use hashbrown::HashSet;

use super::*;

/// The file ID.
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(transparent))]
#[repr(transparent)]
pub struct Fid(u32);

impl From<u32> for Fid {
  #[inline]
  fn from(fid: u32) -> Self {
    Self(fid)
  }
}

impl From<Fid> for u32 {
  #[inline]
  fn from(fid: Fid) -> Self {
    fid.0
  }
}

impl core::fmt::Display for Fid {
  #[inline]
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    write!(f, "{}", self.0)
  }
}

impl crate::Data for Fid {
  type Error = core::convert::Infallible;

  fn encoded_size(&self) -> usize {
    mem::size_of::<u32>()
  }

  fn encode(&self, buf: &mut [u8]) -> Result<usize, Self::Error> {
    buf.copy_from_slice(&self.0.to_le_bytes());
    Ok(mem::size_of::<u32>())
  }

  fn decode(buf: &[u8]) -> Result<(usize, Self), Self::Error> {
    let fid = u32::from_le_bytes(buf.try_into().unwrap());
    Ok((mem::size_of::<u32>(), Self(fid)))
  }
}

/// Manifest represents the contents of the MANIFEST file in a store based on bitcask + wisckey.
///
/// The MANIFEST file describes the startup state of the db -- all logs files.
///
/// It consists of a sequence of [`Fid`]. Each of these is treated atomically,
/// and contains a sequence of [`Fid`]'s (file creations/deletions) which we use to
/// reconstruct the manifest at startup.
///
/// The first bit of the [`CustomFlags`] is used to differentiate between log and value log files.
/// If the bit is set, then it's a value log file, otherwise it's a log file.
#[derive(Debug, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Manifest {
  vlogs: HashSet<Fid>,
  logs: HashSet<Fid>,

  // Contains total number of creation and deletion changes in the manifest -- used to compute
  // whether it'd be useful to rewrite the manifest.
  creations: u64,
  deletions: u64,
}

impl Manifest {
  /// Create a new manifest.
  #[inline]
  pub fn new() -> Self {
    Self {
      vlogs: HashSet::new(),
      logs: HashSet::new(),
      creations: 0,
      deletions: 0,
    }
  }
}

impl crate::BackedManifest for Manifest {
  type Data = Fid;

  type Error = core::convert::Infallible;

  fn insert(&mut self, entry: Entry<Self::Data>) -> Result<(), Self::Error> {
    if entry.flag().is_deletion() {
      self.deletions += 1;
    } else {
      self.creations += 1;
    }

    if entry.flag().custom_flag().bit1() {
      self.vlogs.insert(entry.data);
    } else {
      self.logs.insert(entry.data);
    }
    Ok(())
  }

  fn into_iter(self) -> impl Iterator<Item = Entry<Self::Data>> {
    self
      .logs
      .into_iter()
      .map(|fid| Entry {
        data: fid,
        flag: EntryFlags::creation(),
      })
      .chain(self.vlogs.into_iter().map(|fid| Entry {
        data: fid,
        flag: EntryFlags::creation_with_custom_flag(CustomFlags::empty().with_bit1()),
      }))
  }

  #[inline]
  fn deletions(&self) -> u64 {
    self.deletions
  }

  fn creations(&self) -> u64 {
    self.creations
  }
}