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
//! `WALFilter` allows an application to inspect write-ahead-log (WAL)
//! records or modify their processing on recovery.
use std::collections::BTreeMap;
use std::os::raw::c_int;
use crate::write_batch::WriteBatch;
#[derive(Debug, Clone)]
pub enum WalProcessingOption {
/// Continue processing as usual
ContinueProcessing,
/// Continue processing and change write batch
ContinueAndChangeBatch(WriteBatch),
/// Ignore the current record but continue processing of log(s)
IgnoreCurrentRecord,
/// Stop replay of logs and discard logs.
/// Logs won't be replayed on subsequent recovery
StopReplay,
/// Corrupted record detected by filter
CorruptedRecord,
}
impl WalProcessingOption {
fn to_c(&self) -> c_int {
use self::WalProcessingOption::*;
match *self {
ContinueProcessing |
ContinueAndChangeBatch(_) => 0,
IgnoreCurrentRecord => 1,
StopReplay => 2,
CorruptedRecord => 3,
}
}
}
/// `WALFilter` allows an application to inspect write-ahead-log (WAL)
/// records or modify their processing on recovery.
pub trait WalFilter {
/// Provide `ColumnFamily->LogNumber` map to filter
///
/// so that filter can determine whether a log number applies to a given
/// column family (i.e. that log hasn't been flushed to SST already for the
/// column family).
///
/// We also pass in name->id map as only name is known during
/// recovery (as handles are opened post-recovery).
/// while write batch callbacks happen in terms of column family id.
///
/// # Arguments
///
/// * cf_lognumber_map - column_family_id to lognumber map
/// * cf_name_id_map - column_family_name to column_family_id map
fn column_family_log_number_map(
&mut self,
cf_lognumber_map: &BTreeMap<u32, u64>,
cf_name_id_map: &BTreeMap<String, u32>,
) {
}
/// LogRecord is invoked for each log record encountered for all the logs
/// during replay on logs on recovery. This method can be used to:
///
/// * inspect the record (using the batch parameter)
/// * ignoring current record
/// (by returning WalProcessingOption::kIgnoreCurrentRecord)
/// * reporting corrupted record
/// (by returning WalProcessingOption::kCorruptedRecord)
/// * stop log replay
/// (by returning kStop replay) - please note that this implies
/// discarding the logs from current record onwards.
///
/// # Arguments
///
/// * log_number - log_number of the current log.
///
/// Filter might use this to determine if the log
/// record is applicable to a certain column family.
/// * log_file_name - log file name - only for informational purposes
/// * batch - batch encountered in the log during recovery
/// * new_batch- new_batch to populate if filter wants to change
/// the batch (for example to filter some records out,
/// or alter some records).
///
/// Please note that the new batch MUST NOT contain
/// more records than original, else recovery would
/// be failed.
/// * batch_changed - Whether batch was changed by the filter.
/// It must be set to true if new_batch was populated,
/// else new_batch has no effect.
///
/// Returns Processing option for the current record.
///
/// Please see `WalProcessingOption` enum above for
/// details.
fn log_record_found(&self, log_number: u64, log_file_name: &str, batch: &WriteBatch) -> WalProcessingOption {
WalProcessingOption::ContinueProcessing
}
/// Returns a name that identifies this WAL filter.
///
/// The name will be printed to LOG file on start up for diagnosis.
fn name(&self) -> &str {
"RustWalFilter\0"
}
}