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