Skip to main content

mysql_replication/engine/
processor.rs

1use crate::{
2    Result,
3    engine::checkpoint::State,
4    engine::transaction::TransactionBuffer,
5    error::invalid,
6    protocol::mysql::event_type as event,
7    protocol::mysql::events::{EventParser, ParsedEvent},
8    protocol::mysql::file::EventView,
9    protocol::mysql::version::{
10        EventAction, FormatDescription, RowDecoder, VersionAdapter, VersionRegistry,
11    },
12};
13use std::{
14    io::Write,
15    path::{Path, PathBuf},
16    sync::Arc,
17};
18
19/// Per-source transaction engine; adapters own version-specific decoding.
20pub struct Processor {
21    decoder: Option<Box<dyn RowDecoder>>,
22    event_parser: Option<Box<dyn EventParser>>,
23    adapter: Option<Arc<dyn VersionAdapter>>,
24    registry: VersionRegistry,
25    selected_adapter: Option<String>,
26    transaction: TransactionBuffer,
27    state: State,
28    state_path: Option<PathBuf>,
29}
30impl Processor {
31    pub fn new(
32        state: State,
33        state_path: Option<PathBuf>,
34        transaction_budget: usize,
35    ) -> Result<Self> {
36        Self::with_registry(
37            state,
38            state_path,
39            transaction_budget,
40            VersionRegistry::default(),
41            None,
42        )
43    }
44    pub fn with_registry(
45        state: State,
46        state_path: Option<PathBuf>,
47        transaction_budget: usize,
48        registry: VersionRegistry,
49        selected_adapter: Option<String>,
50    ) -> Result<Self> {
51        state.validate()?;
52        Ok(Self {
53            decoder: None,
54            event_parser: None,
55            adapter: None,
56            registry,
57            selected_adapter,
58            transaction: TransactionBuffer::new(transaction_budget),
59            state,
60            state_path,
61        })
62    }
63    pub fn state(&self) -> &State {
64        &self.state
65    }
66    pub fn finish(&self) -> Result<()> {
67        if self.decoder.is_none() {
68            return Err(invalid("stream ended without FORMAT_DESCRIPTION"));
69        }
70        if self.transaction.is_active() {
71            return Err(invalid(
72                "stream ended inside a transaction; checkpoint was not advanced",
73            ));
74        }
75        Ok(())
76    }
77    pub fn process(
78        &mut self,
79        event: EventView<'_>,
80        output: &mut (impl Write + Send),
81    ) -> Result<()> {
82        self.process_to(event, &crate::sink::JsonLinesSink::new(output))
83    }
84    pub fn process_to(
85        &mut self,
86        event: EventView<'_>,
87        sink: &dyn crate::sink::TransactionSink,
88    ) -> Result<()> {
89        self.process_inner(event, |tx, state, path| {
90            tx.commit_with(state, path, |changes| {
91                sink.commit(&state.source_id, state, changes)
92            })
93        })
94    }
95    fn process_inner(
96        &mut self,
97        event: EventView<'_>,
98        commit: impl FnOnce(&mut TransactionBuffer, &State, Option<&Path>) -> Result<()>,
99    ) -> Result<()> {
100        if event.event_type != event::FORMAT_DESCRIPTION_EVENT
101            && event.event_type != event::ROTATE_EVENT
102            && self.decoder.is_none()
103        {
104            return Err(invalid("event before FORMAT_DESCRIPTION"));
105        }
106        if event.log_pos != 0
107            && !matches!(
108                event.event_type,
109                event::HEARTBEAT_EVENT | event::HEARTBEAT_LOG_EVENT_V2
110            )
111        {
112            self.state.position = u64::from(event.log_pos);
113        }
114        if event.event_type == event::FORMAT_DESCRIPTION_EVENT {
115            if self.transaction.is_active() {
116                return Err(invalid("FORMAT_DESCRIPTION inside transaction"));
117            }
118            let format = FormatDescription::parse(event.data)?;
119            // Select using the file's producer version, including historical files
120            // being replayed after an upstream server upgrade.
121            let adapter = self
122                .registry
123                .resolve(&format.server, self.selected_adapter.as_deref())?;
124            adapter.validate_format(&format)?;
125            let parser = adapter.create_event_parser(&format)?;
126            let decoder = adapter.create_decoder(self.state.tables.clone(), &format)?;
127            self.event_parser = Some(parser);
128            self.decoder = Some(decoder);
129            self.adapter = Some(adapter);
130            return Ok(());
131        }
132        let parsed = if let Some(parser) = &self.event_parser {
133            parser.parse(event)?
134        } else {
135            // A fake ROTATE can precede the first FDE in a v4 dump stream.
136            ParsedEvent::Control(crate::protocol::mysql::version::classify_mysql_event(
137                event,
138            )?)
139        };
140        let action = match parsed {
141            ParsedEvent::TableMap(table_map) => {
142                return self
143                    .decoder
144                    .as_mut()
145                    .ok_or_else(|| invalid("TABLE_MAP without decoder"))?
146                    .table_map_event(table_map);
147            }
148            ParsedEvent::Rows(rows) => {
149                let tx = &mut self.transaction;
150                return self
151                    .decoder
152                    .as_mut()
153                    .ok_or_else(|| invalid("ROWS without decoder"))?
154                    .rows_event(rows, &mut |change| tx.push(change));
155            }
156            ParsedEvent::Control(action) => action,
157            ParsedEvent::Unclassified(raw) => self
158                .adapter
159                .as_ref()
160                .ok_or_else(|| invalid("event without adapter"))?
161                .classify(raw)?,
162        };
163        match action {
164            EventAction::Rotate { file, position } => {
165                if self.transaction.is_active() {
166                    return Err(invalid("ROTATE inside transaction"));
167                }
168                self.state.file = file.into();
169                self.state.position = position;
170                if let Some(decoder) = &mut self.decoder {
171                    decoder.clear_table_maps();
172                }
173            }
174            EventAction::Begin => self.transaction.begin()?,
175            EventAction::Commit => commit(
176                &mut self.transaction,
177                &self.state,
178                self.state_path.as_deref(),
179            )?,
180            EventAction::Rollback => {
181                self.transaction.rollback();
182                if let Some(path) = &self.state_path {
183                    self.state.save(path)?;
184                }
185            }
186            EventAction::TableMap | EventAction::Rows => {
187                return Err(invalid(
188                    "EventParser must normalize TABLE_MAP/ROWS into typed views",
189                ));
190            }
191            EventAction::GroupStart if self.transaction.is_active() => {
192                return Err(invalid("new GTID inside unfinished transaction"));
193            }
194            EventAction::GroupStart | EventAction::Ignore => {}
195        }
196        Ok(())
197    }
198}