mysql_replication/engine/
processor.rs1use 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
19pub 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 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 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}