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         8895 :     pub fn new() -> Arc<DiskWalProposer> {
      16         8895 :         Arc::new(DiskWalProposer {
      17         8895 :             state: Mutex::new(State {
      18         8895 :                 internal_available_lsn: Lsn(0),
      19         8895 :                 prev_lsn: Lsn(0),
      20         8895 :                 disk: BlockStorage::new(),
      21         8895 :                 wal_generator: WalGenerator::new(LogicalMessageGenerator::new(c"", &[])),
      22         8895 :             }),
      23         8895 :         })
      24         8895 :     }
      25              : 
      26        15130 :     pub fn lock(&self) -> MutexGuard<State> {
      27        15130 :         self.state.lock()
      28        15130 :     }
      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          916 :     pub fn read(&self, pos: u64, buf: &mut [u8]) {
      44          916 :         self.disk.read(pos, buf);
      45          916 :         // TODO: fail on reading uninitialized data
      46          916 :     }
      47              : 
      48          147 :     pub fn write(&mut self, pos: u64, buf: &[u8]) {
      49          147 :         self.disk.write(pos, buf);
      50          147 :     }
      51              : 
      52              :     /// Update the internal available LSN to the given value.
      53          361 :     pub fn reset_to(&mut self, lsn: Lsn) {
      54          361 :         self.internal_available_lsn = lsn;
      55          361 :         self.prev_lsn = Lsn(0); // Safekeeper doesn't care if this is omitted
      56          361 :         self.wal_generator.lsn = self.internal_available_lsn;
      57          361 :         self.wal_generator.prev_lsn = self.prev_lsn;
      58          361 :     }
      59              : 
      60              :     /// Get current LSN.
      61         1996 :     pub fn flush_rec_ptr(&self) -> Lsn {
      62         1996 :         self.internal_available_lsn
      63         1996 :     }
      64              : 
      65              :     /// Inserts a logical record in the WAL at the current LSN.
      66        11710 :     pub fn insert_logical_message(&mut self, prefix: &CStr, msg: &[u8]) {
      67        11710 :         let (_, record) = self.wal_generator.append_logical_message(prefix, msg);
      68        11710 :         self.disk.write(self.internal_available_lsn.into(), &record);
      69        11710 :         self.prev_lsn = self.internal_available_lsn;
      70        11710 :         self.internal_available_lsn += record.len() as u64;
      71        11710 :     }
      72              : }