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, error::invalid,
4    events::EventHeader, parser::ParserConfig,
5};
6use std::io::Read;
7
8pub struct BinlogFile<R> {
9    reader: R,
10    buffer: Vec<u8>,
11    framing: FrameDecoder,
12    parser: BinlogParser,
13}
14impl<R: Read> BinlogFile<R> {
15    pub fn new(reader: R) -> Result<Self> {
16        Self::with_config(reader, ParserConfig::default())
17    }
18    pub fn with_config(mut reader: R, config: ParserConfig) -> Result<Self> {
19        let mut magic = [0; 4];
20        reader.read_exact(&mut magic)?;
21        if magic != [0xfe, b'b', b'i', b'n'] {
22            return Err(invalid("binlog magic"));
23        }
24        Ok(Self {
25            reader,
26            buffer: Vec::new(),
27            framing: FrameDecoder::new(),
28            parser: BinlogParser::new(config),
29        })
30    }
31    /// Reads only a frame, so custom adapters can select their own body layout.
32    pub fn next_frame(&mut self) -> Result<Option<BinlogFrame<'_>>> {
33        read_frame(&mut self.reader, &mut self.buffer, &mut self.framing)
34    }
35    pub fn next_event(&mut self) -> Result<Option<BinlogEvent<'_>>> {
36        let Some(frame) = read_frame(&mut self.reader, &mut self.buffer, &mut self.framing)? else {
37            return Ok(None);
38        };
39        self.parser.parse(frame).map(Some)
40    }
41}
42fn read_frame<'a>(
43    reader: &mut impl Read,
44    buffer: &'a mut Vec<u8>,
45    framing: &mut FrameDecoder,
46) -> Result<Option<BinlogFrame<'a>>> {
47    let mut header = [0; 19];
48    loop {
49        match reader.read(&mut header[..1]) {
50            Ok(0) => {
51                return if framing.has_format() {
52                    Ok(None)
53                } else {
54                    Err(invalid("binlog has no FORMAT_DESCRIPTION"))
55                };
56            }
57            Ok(_) => break,
58            Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
59            Err(e) => return Err(e.into()),
60        }
61    }
62    reader.read_exact(&mut header[1..])?;
63    let length = EventHeader::parse(&header)?.event_size as usize;
64    if !(19..=MAX_EVENT_BYTES).contains(&length) {
65        return Err(invalid("event size outside 19..64MiB"));
66    }
67    buffer.resize(length, 0);
68    buffer[..19].copy_from_slice(&header);
69    reader.read_exact(&mut buffer[19..])?;
70    framing.decode(buffer).map(Some)
71}