waof 0.1.2

Append-Only File (AOF) write-ahead log for replication
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

use std::{path::Path, sync::Arc};

use aok::Result;
use tempfile::{TempDir, tempdir};
use waof::{WalConfig, WalLog};
use wdev::SegmentedDevice;

/// 测试夹具：封装临时目录与 WalLog 实例
pub struct WalFixture {
  pub dir: TempDir,
  pub wal: Arc<WalLog<SegmentedDevice>>,
}

impl WalFixture {
  /// 创建基于单文件设备的 WalLog 夹具
  pub fn single_file(file_name: &str, buf_size: usize) -> Result<Self> {
    let dir = tempdir()?;
    let db_path = dir.path().join(file_name);
    let device = Arc::new(SegmentedDevice::single_file(&db_path)?);
    let config = WalConfig::new(buf_size);
    let wal = Arc::new(WalLog::new(device, config)?);
    Ok(Self { dir, wal })
  }

  /// 创建基于分段设备的 WalLog 夹具
  pub fn segmented(file_name: &str, seg_size: u64, buf_size: usize) -> Result<Self> {
    let dir = tempdir()?;
    let db_path = dir.path().join(file_name);
    let device = Arc::new(SegmentedDevice::segmented(&db_path, seg_size)?);
    let config = WalConfig::new(buf_size);
    let wal = Arc::new(WalLog::new(device, config)?);
    Ok(Self { dir, wal })
  }
}

/// 重新打开已有的分段 WalLog
pub async fn reopen_segmented(
  dir: &Path,
  file_name: &str,
  seg_size: u64,
  buf_size: usize,
) -> Result<WalLog<SegmentedDevice>> {
  let db_path = dir.join(file_name);
  let device = Arc::new(SegmentedDevice::segmented(&db_path, seg_size)?);
  let config = WalConfig::new(buf_size);
  let wal = WalLog::open(device, config).await?;
  Ok(wal)
}

/// 重新打开已有的单文件 WalLog
pub async fn reopen_single_file(
  dir: &Path,
  file_name: &str,
  buf_size: usize,
) -> Result<WalLog<SegmentedDevice>> {
  let db_path = dir.join(file_name);
  let device = Arc::new(SegmentedDevice::single_file(&db_path)?);
  let config = WalConfig::new(buf_size);
  let wal = WalLog::open(device, config).await?;
  Ok(wal)
}

/// 生成指定长度与统一字节内容的测试负载
pub fn make_payload(len: usize, byte: u8) -> Vec<u8> {
  vec![byte; len]
}

/// 生成带有递增序列特征的测试负载（对标 C# TsavoriteLog entry 模式）
pub fn make_pattern_payload(index: usize, len: usize) -> Vec<u8> {
  (0..len).map(|j| ((index + j) % 256) as u8).collect()
}

/// 伪造短写入的设备包装：底层写成功后仅报告一半字节，验证 commit 持久化守卫
pub struct ShortWriteDevice {
  pub inner: SegmentedDevice,
}

impl ShortWriteDevice {
  pub fn single_file(path: &Path) -> Result<Self> {
    Ok(Self {
      inner: SegmentedDevice::single_file(path)?,
    })
  }
}

impl wdev::Device for ShortWriteDevice {
  fn sector_size(&self) -> usize {
    self.inner.sector_size()
  }

  fn segment_size(&self) -> Option<u64> {
    self.inner.segment_size()
  }

  fn pool(&self) -> &Arc<wram::BufferPool> {
    self.inner.pool()
  }

  async fn write_aligned(
    &self,
    offset: u64,
    buf: wram::AlignedBuf,
  ) -> (wdev::Result<usize>, wram::AlignedBuf) {
    let expected = buf.len();
    let (res, buf) = self.inner.write_aligned(offset, buf).await;
    (res.map(|_| expected / 2), buf)
  }

  async fn read_aligned(
    &self,
    offset: u64,
    buf: wram::AlignedBuf,
  ) -> (wdev::Result<usize>, wram::AlignedBuf) {
    self.inner.read_aligned(offset, buf).await
  }

  async fn read_raw(
    &self,
    offset: u64,
    buf: wram::AlignedBuf,
  ) -> (wdev::Result<usize>, wram::AlignedBuf) {
    self.inner.read_raw(offset, buf).await
  }

  async fn sync(&self) -> wdev::Result<()> {
    self.inner.sync().await
  }

  async fn truncate_until_segment(&self, segment_id: u32) -> wdev::Result<()> {
    self.inner.truncate_until_segment(segment_id).await
  }
}