Skip to main content

mysql_replication/
file.rs

1//! Bounded binlog files share framing and event parsing with network replication.
2use crate::{
3    BinlogEvent, BinlogFrame, BinlogParser, FrameDecoder, MAX_EVENT_BYTES, Result,
4    error::invalid,
5    events::{BinlogMode, EventHeader},
6    parser::ParserConfig,
7};
8use std::io::Read;
9
10/// Validated raw file frames for custom protocol adapters.
11pub struct FrameReader<R> {
12    reader: R,
13    buffer: Vec<u8>,
14    framing: FrameDecoder,
15}
16impl<R: Read> FrameReader<R> {
17    pub fn new(mut reader: R) -> Result<Self> {
18        let mut magic = [0; 4];
19        reader.read_exact(&mut magic)?;
20        if magic != [0xfe, b'b', b'i', b'n'] {
21            return Err(invalid("binlog magic"));
22        }
23        Ok(Self {
24            reader,
25            buffer: Vec::new(),
26            framing: FrameDecoder::new(),
27        })
28    }
29    pub fn next_frame(&mut self) -> Result<Option<BinlogFrame<'_>>> {
30        read_frame(&mut self.reader, &mut self.buffer, &mut self.framing)
31    }
32}
33
34/// A file reader whose field policy is fixed at construction.
35pub struct BinlogFile<R, M: BinlogMode> {
36    frames: FrameReader<R>,
37    parser: BinlogParser<M>,
38}
39impl<R: Read, M: BinlogMode> BinlogFile<R, M> {
40    pub fn new(reader: R, config: ParserConfig) -> Result<Self> {
41        Ok(Self {
42            frames: FrameReader::new(reader)?,
43            parser: BinlogParser::new(config),
44        })
45    }
46    pub fn next_event(&mut self) -> Result<Option<BinlogEvent<'_, M>>> {
47        let Some(frame) = self.frames.next_frame()? else {
48            return Ok(None);
49        };
50        self.parser.parse(frame).map(Some)
51    }
52}
53
54fn read_frame<'a>(
55    reader: &mut impl Read,
56    buffer: &'a mut Vec<u8>,
57    framing: &mut FrameDecoder,
58) -> Result<Option<BinlogFrame<'a>>> {
59    let mut header = [0; 19];
60    loop {
61        match reader.read(&mut header[..1]) {
62            Ok(0) => {
63                return if framing.has_format() {
64                    Ok(None)
65                } else {
66                    Err(invalid("binlog has no FORMAT_DESCRIPTION"))
67                };
68            }
69            Ok(_) => break,
70            Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
71            Err(e) => return Err(e.into()),
72        }
73    }
74    reader.read_exact(&mut header[1..])?;
75    let length = EventHeader::parse(&header)?.event_size as usize;
76    if !(19..=MAX_EVENT_BYTES).contains(&length) {
77        return Err(invalid("event size outside 19..64MiB"));
78    }
79    buffer.resize(length, 0);
80    buffer[..19].copy_from_slice(&header);
81    reader.read_exact(&mut buffer[19..])?;
82    framing.decode(buffer).map(Some)
83}