mysql_replication/
file.rs1use 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 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}