TLA  Line data    Source code

       1                 : //! Synthetic size calculation
       2                 : 
       3                 : mod calculation;
       4                 : pub mod svg;
       5                 : 
       6                 : /// StorageModel is the input to the synthetic size calculation. It represents
       7                 : /// a tree of timelines, with just the information that's needed for the
       8                 : /// calculation. This doesn't track timeline names or where each timeline
       9                 : /// begins and ends, for example. Instead, it consists of "points of interest"
      10                 : /// on the timelines. A point of interest could be the timeline start or end point,
      11                 : /// the oldest point on a timeline that needs to be retained because of PITR
      12                 : /// cutoff, or snapshot points named by the user. For each such point, and the
      13                 : /// edge connecting the points (implicit in Segment), we store information about
      14                 : /// whether we need to be able to recover to the point, and if known, the logical
      15                 : /// size at the point.
      16                 : ///
      17                 : /// The segments must form a well-formed tree, with no loops.
      18 UBC           0 : #[derive(serde::Serialize)]
      19                 : pub struct StorageModel {
      20                 :     pub segments: Vec<Segment>,
      21                 : }
      22                 : 
      23                 : /// Segment represents one point in the tree of branches, *and* the edge that leads
      24                 : /// to it (if any). We don't need separate structs for points and edges, because each
      25                 : /// point can have only one parent.
      26                 : ///
      27                 : /// When 'needed' is true, it means that we need to be able to reconstruct
      28                 : /// any version between 'parent.lsn' and 'lsn'. If you want to represent that only
      29                 : /// a single point is needed, create two Segments with the same lsn, and mark only
      30                 : /// the child as needed.
      31                 : ///
      32 CBC         366 : #[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
      33                 : pub struct Segment {
      34                 :     /// Previous segment index into ['Storage::segments`], if any.
      35                 :     pub parent: Option<usize>,
      36                 : 
      37                 :     /// LSN at this point
      38                 :     pub lsn: u64,
      39                 : 
      40                 :     /// Logical size at this node, if known.
      41                 :     pub size: Option<u64>,
      42                 : 
      43                 :     /// If true, the segment from parent to this node is needed by `retention_period`
      44                 :     pub needed: bool,
      45                 : }
      46                 : 
      47                 : /// Result of synthetic size calculation. Returned by StorageModel::calculate()
      48                 : pub struct SizeResult {
      49                 :     pub total_size: u64,
      50                 : 
      51                 :     // This has same length as the StorageModel::segments vector in the input.
      52                 :     // Each entry in this array corresponds to the entry with same index in
      53                 :     // StorageModel::segments.
      54                 :     pub segments: Vec<SegmentSizeResult>,
      55                 : }
      56                 : 
      57             286 : #[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
      58                 : pub struct SegmentSizeResult {
      59                 :     pub method: SegmentMethod,
      60                 :     // calculated size of this subtree, using this method
      61                 :     pub accum_size: u64,
      62                 : }
      63                 : 
      64                 : /// Different methods to retain history from a particular state
      65            1394 : #[derive(Clone, Copy, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
      66                 : pub enum SegmentMethod {
      67                 :     SnapshotHere, // A logical snapshot is needed after this segment
      68                 :     Wal,          // Keep WAL leading up to this node
      69                 :     Skipped,
      70                 : }