Line data    Source code

       1              : use std::{ffi::CStr, sync::Arc};
       2              : 
       3              : use parking_lot::{Mutex, MutexGuard};
       4              : use postgres_ffi::v16::wal_generator::{LogicalMessageGenerator, WalGenerator};
       5              : use utils::lsn::Lsn;
       6              : 
       7              : use super::block_storage::BlockStorage;
       8              : 
       9              : /// Simulation implementation of walproposer WAL storage.
      10              : pub struct DiskWalProposer {
      11              :     state: Mutex<State>,
      12              : }
      13              : 
      14              : impl DiskWalProposer {
      15         9808 :     pub fn new() -> Arc<DiskWalProposer> {
      16         9808 :         Arc::new(DiskWalProposer {
      17         9808 :             state: Mutex::new(State {
      18         9808 :                 internal_available_lsn: Lsn(0),
      19         9808 :                 prev_lsn: Lsn(0),
      20         9808 :                 disk: BlockStorage::new(),
      21         9808 :                 wal_generator: WalGenerator::new(LogicalMessageGenerator::new(c"", &[])),
      22         9808 :             }),
      23         9808 :         })
      24         9808 :     }
      25              : 
      26        16833 :     pub fn lock(&self) -> MutexGuard<State> {
      27        16833 :         self.state.lock()
      28        16833 :     }
      29              : }
      30              : 
      31              : pub struct State {
      32              :     // flush_lsn
      33              :     internal_available_lsn: Lsn,
      34              :     // needed for WAL generation
      35              :     prev_lsn: Lsn,
      36              :     // actual WAL storage
      37              :     disk: BlockStorage,
      38              :     // WAL record generator
      39              :     wal_generator: WalGenerator<LogicalMessageGenerator>,
      40              : }
      41              : 
      42              : impl State {
      43         1294 :     pub fn read(&self, pos: u64, buf: &mut [u8]) {
      44         1294 :         self.disk.read(pos, buf);
      45         1294 :         // TODO: fail on reading uninitialized data
      46         1294 :     }
      47              : 
      48          294 :     pub fn write(&mut self, pos: u64, buf: &[u8]) {
      49          294 :         self.disk.write(pos, buf);
      50          294 :     }
      51              : 
      52              :     /// Update the internal available LSN to the given value.
      53          497 :     pub fn reset_to(&mut self, lsn: Lsn) {
      54          497 :         self.internal_available_lsn = lsn;
      55          497 :         self.prev_lsn = Lsn(0); // Safekeeper doesn't care if this is omitted
      56          497 :         self.wal_generator.lsn = self.internal_available_lsn;
      57          497 :         self.wal_generator.prev_lsn = self.prev_lsn;
      58          497 :     }
      59              : 
      60              :     /// Get current LSN.
      61         2493 :     pub fn flush_rec_ptr(&self) -> Lsn {
      62         2493 :         self.internal_available_lsn
      63         2493 :     }
      64              : 
      65              :     /// Inserts a logical record in the WAL at the current LSN.
      66        12255 :     pub fn insert_logical_message(&mut self, prefix: &CStr, msg: &[u8]) {
      67        12255 :         let (_, record) = self.wal_generator.append_logical_message(prefix, msg);
      68        12255 :         self.disk.write(self.internal_available_lsn.into(), &record);
      69        12255 :         self.prev_lsn = self.internal_available_lsn;
      70        12255 :         self.internal_available_lsn += record.len() as u64;
      71        12255 :     }
      72              : }