1use byteorder::{ByteOrder, LittleEndian};
16use std::fmt;
17
18use crate::{Result, ResyncStateError};
19
20pub use crate::filemeta::{MrfOpKind, MrfReplicateEntry};
21
22pub const MRF_META_FORMAT: u16 = 1;
23pub const MRF_META_VERSION: u16 = 1;
24
25const MRF_ENVELOPE_MAGIC: [u8; 4] = *b"MRFE";
26const MRF_ENVELOPE_HEADER_LEN: usize = 24;
27pub const MRF_ENVELOPE_FORMAT: u16 = 1;
28pub const MRF_ENVELOPE_VERSION: u16 = 1;
29
30const CAPABILITY_OPERATION_KIND: u64 = 1 << 0;
31const CAPABILITY_TARGET_ARNS: u64 = 1 << 1;
32const CAPABILITY_FORCE_DELETE: u64 = 1 << 2;
33const CAPABILITY_DELETE_MARKER_MTIME: u64 = 1 << 3;
34const CAPABILITY_TARGET_DELETE_MARKER_VERSION_IDS: u64 = 1 << 4;
36const MRF_KNOWN_CAPABILITIES: u64 = CAPABILITY_OPERATION_KIND
37 | CAPABILITY_TARGET_ARNS
38 | CAPABILITY_FORCE_DELETE
39 | CAPABILITY_DELETE_MARKER_MTIME
40 | CAPABILITY_TARGET_DELETE_MARKER_VERSION_IDS;
41
42#[derive(Debug, Clone, Copy, PartialEq, Eq)]
43pub enum MrfCapability {
44 OperationKind,
45 TargetArns,
46 ForceDelete,
47 DeleteMarkerMtime,
48 TargetDeleteMarkerVersionIds,
49}
50
51impl MrfCapability {
52 const fn bit(self) -> u64 {
53 match self {
54 Self::OperationKind => CAPABILITY_OPERATION_KIND,
55 Self::TargetArns => CAPABILITY_TARGET_ARNS,
56 Self::ForceDelete => CAPABILITY_FORCE_DELETE,
57 Self::DeleteMarkerMtime => CAPABILITY_DELETE_MARKER_MTIME,
58 Self::TargetDeleteMarkerVersionIds => CAPABILITY_TARGET_DELETE_MARKER_VERSION_IDS,
59 }
60 }
61}
62
63#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
64pub struct MrfCapabilities(u64);
65
66impl MrfCapabilities {
67 pub const fn current() -> Self {
68 Self(MRF_KNOWN_CAPABILITIES)
69 }
70
71 pub const fn empty() -> Self {
72 Self(0)
73 }
74
75 pub const fn with(capability: MrfCapability) -> Self {
76 Self(capability.bit())
77 }
78
79 pub const fn bits(self) -> u64 {
80 self.0
81 }
82
83 pub const fn contains(self, capability: MrfCapability) -> bool {
84 self.0 & capability.bit() != 0
85 }
86
87 pub const fn supports(self, required: Self) -> bool {
88 self.0 & required.0 == required.0
89 }
90
91 pub fn from_bits(bits: u64) -> std::result::Result<Self, MrfEnvelopeError> {
92 let unknown = bits & !MRF_KNOWN_CAPABILITIES;
93 if unknown != 0 {
94 return Err(MrfEnvelopeError::UnknownCapabilities { bits: unknown });
95 }
96 Ok(Self(bits))
97 }
98}
99
100#[derive(Debug, Clone, Copy, PartialEq, Eq)]
101pub struct MrfProtocolCapabilities {
102 version: u16,
103 min_reader_version: u16,
104 capabilities: MrfCapabilities,
105}
106
107impl MrfProtocolCapabilities {
108 pub const fn new(version: u16, min_reader_version: u16, capabilities: MrfCapabilities) -> Self {
109 Self {
110 version,
111 min_reader_version,
112 capabilities,
113 }
114 }
115
116 pub const fn current() -> Self {
117 Self {
118 version: MRF_ENVELOPE_VERSION,
119 min_reader_version: MRF_ENVELOPE_VERSION,
120 capabilities: MrfCapabilities::current(),
121 }
122 }
123
124 pub const fn version(self) -> u16 {
125 self.version
126 }
127
128 pub const fn min_reader_version(self) -> u16 {
129 self.min_reader_version
130 }
131
132 pub const fn capabilities(self) -> MrfCapabilities {
133 self.capabilities
134 }
135
136 pub fn negotiate(self, peer: Self) -> std::result::Result<Self, MrfEnvelopeError> {
137 MrfCapabilities::from_bits(self.capabilities.bits())?;
138 MrfCapabilities::from_bits(peer.capabilities.bits())?;
139 if self.min_reader_version > self.version {
140 return Err(MrfEnvelopeError::InvalidVersionRange {
141 version: self.version,
142 min_reader_version: self.min_reader_version,
143 });
144 }
145 if peer.min_reader_version > peer.version {
146 return Err(MrfEnvelopeError::InvalidVersionRange {
147 version: peer.version,
148 min_reader_version: peer.min_reader_version,
149 });
150 }
151 if self.version < MRF_ENVELOPE_VERSION {
152 return Err(MrfEnvelopeError::UnsupportedVersion { version: self.version });
153 }
154 if peer.version < MRF_ENVELOPE_VERSION {
155 return Err(MrfEnvelopeError::UnsupportedVersion { version: peer.version });
156 }
157 if peer.min_reader_version > self.version {
158 return Err(MrfEnvelopeError::RollbackFenced {
159 min_reader_version: peer.min_reader_version,
160 supported_version: self.version,
161 });
162 }
163 if self.min_reader_version > peer.version {
164 return Err(MrfEnvelopeError::RollbackFenced {
165 min_reader_version: self.min_reader_version,
166 supported_version: peer.version,
167 });
168 }
169 Ok(Self {
170 version: self.version.min(peer.version),
171 min_reader_version: self.min_reader_version.max(peer.min_reader_version),
172 capabilities: MrfCapabilities(self.capabilities.bits() & peer.capabilities.bits()),
173 })
174 }
175}
176
177#[derive(Debug, Clone, PartialEq, Eq)]
178pub struct MrfEnvelope {
179 protocol: MrfProtocolCapabilities,
180 payload: Vec<u8>,
181}
182
183impl MrfEnvelope {
184 pub fn new(protocol: MrfProtocolCapabilities, payload: Vec<u8>) -> std::result::Result<Self, MrfEnvelopeError> {
185 if protocol.version != MRF_ENVELOPE_VERSION {
186 return Err(MrfEnvelopeError::UnsupportedVersion {
187 version: protocol.version,
188 });
189 }
190 if protocol.min_reader_version > protocol.version {
191 return Err(MrfEnvelopeError::InvalidVersionRange {
192 version: protocol.version,
193 min_reader_version: protocol.min_reader_version,
194 });
195 }
196 MrfCapabilities::from_bits(protocol.capabilities.bits())?;
197 Ok(Self { protocol, payload })
198 }
199
200 pub const fn protocol(&self) -> MrfProtocolCapabilities {
201 self.protocol
202 }
203
204 pub fn payload(&self) -> &[u8] {
205 &self.payload
206 }
207
208 pub fn encode(&self) -> std::result::Result<Vec<u8>, MrfEnvelopeError> {
209 let payload_len: u32 = self.payload.len().try_into().map_err(|_| MrfEnvelopeError::PayloadTooLarge)?;
210 let mut data = Vec::with_capacity(MRF_ENVELOPE_HEADER_LEN + self.payload.len());
211 data.extend_from_slice(&MRF_ENVELOPE_MAGIC);
212 data.extend_from_slice(&MRF_ENVELOPE_FORMAT.to_le_bytes());
213 data.extend_from_slice(&self.protocol.version.to_le_bytes());
214 data.extend_from_slice(&self.protocol.min_reader_version.to_le_bytes());
215 data.extend_from_slice(&0u16.to_le_bytes());
216 data.extend_from_slice(&self.protocol.capabilities.bits().to_le_bytes());
217 data.extend_from_slice(&payload_len.to_le_bytes());
218 data.extend_from_slice(&self.payload);
219 Ok(data)
220 }
221
222 pub fn decode(data: &[u8], supported: MrfProtocolCapabilities) -> std::result::Result<Self, MrfEnvelopeError> {
223 if data.len() < MRF_ENVELOPE_HEADER_LEN {
224 return Err(MrfEnvelopeError::Truncated);
225 }
226 if data[..4] != MRF_ENVELOPE_MAGIC {
227 return Err(MrfEnvelopeError::InvalidMagic);
228 }
229 let format = LittleEndian::read_u16(&data[4..6]);
230 if format != MRF_ENVELOPE_FORMAT {
231 return Err(MrfEnvelopeError::UnsupportedFormat { format });
232 }
233 let version = LittleEndian::read_u16(&data[6..8]);
234 if version < MRF_ENVELOPE_VERSION {
235 return Err(MrfEnvelopeError::UnsupportedVersion { version });
236 }
237 let min_reader_version = LittleEndian::read_u16(&data[8..10]);
238 if min_reader_version > supported.version {
239 return Err(MrfEnvelopeError::RollbackFenced {
240 min_reader_version,
241 supported_version: supported.version,
242 });
243 }
244 if min_reader_version > version {
245 return Err(MrfEnvelopeError::InvalidVersionRange {
246 version,
247 min_reader_version,
248 });
249 }
250 let reserved = LittleEndian::read_u16(&data[10..12]);
251 if reserved != 0 {
252 return Err(MrfEnvelopeError::ReservedHeaderBits { bits: reserved });
253 }
254 let capabilities = MrfCapabilities::from_bits(LittleEndian::read_u64(&data[12..20]))?;
255 if !supported.capabilities.supports(capabilities) {
256 return Err(MrfEnvelopeError::MissingCapabilities {
257 required: capabilities.bits(),
258 available: supported.capabilities.bits(),
259 });
260 }
261 let payload_len = LittleEndian::read_u32(&data[20..24]);
262 let actual_len = data.len() - MRF_ENVELOPE_HEADER_LEN;
263 if usize::try_from(payload_len).map_err(|_| MrfEnvelopeError::PayloadTooLarge)? != actual_len {
264 return Err(MrfEnvelopeError::PayloadLengthMismatch {
265 declared: payload_len,
266 actual: actual_len,
267 });
268 }
269 Ok(Self {
270 protocol: MrfProtocolCapabilities {
271 version,
272 min_reader_version,
273 capabilities,
274 },
275 payload: data[MRF_ENVELOPE_HEADER_LEN..].to_vec(),
276 })
277 }
278}
279
280#[derive(Debug, Clone, PartialEq, Eq)]
281pub enum MrfEnvelopeError {
282 Truncated,
283 InvalidMagic,
284 UnsupportedFormat {
285 format: u16,
286 },
287 UnsupportedVersion {
288 version: u16,
289 },
290 InvalidVersionRange {
291 version: u16,
292 min_reader_version: u16,
293 },
294 RollbackFenced {
295 min_reader_version: u16,
296 supported_version: u16,
297 },
298 ReservedHeaderBits {
299 bits: u16,
300 },
301 UnknownCapabilities {
302 bits: u64,
303 },
304 MissingCapabilities {
305 required: u64,
306 available: u64,
307 },
308 PayloadLengthMismatch {
309 declared: u32,
310 actual: usize,
311 },
312 PayloadTooLarge,
313}
314
315impl fmt::Display for MrfEnvelopeError {
316 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
317 match self {
318 Self::Truncated => write!(f, "truncated MRF envelope"),
319 Self::InvalidMagic => write!(f, "invalid MRF envelope magic"),
320 Self::UnsupportedFormat { format } => write!(f, "unsupported MRF envelope format {format}"),
321 Self::UnsupportedVersion { version } => write!(f, "unsupported MRF envelope version {version}"),
322 Self::InvalidVersionRange {
323 version,
324 min_reader_version,
325 } => {
326 write!(f, "invalid MRF version range: version {version}, minimum reader {min_reader_version}")
327 }
328 Self::RollbackFenced {
329 min_reader_version,
330 supported_version,
331 } => write!(
332 f,
333 "MRF rollback fenced: reader version {supported_version} is below required {min_reader_version}"
334 ),
335 Self::ReservedHeaderBits { bits } => write!(f, "reserved MRF envelope header bits are set: 0x{bits:04x}"),
336 Self::UnknownCapabilities { bits } => write!(f, "unknown MRF capability bits 0x{bits:016x}"),
337 Self::MissingCapabilities { required, available } => {
338 write!(f, "MRF capabilities 0x{available:016x} do not satisfy required 0x{required:016x}")
339 }
340 Self::PayloadLengthMismatch { declared, actual } => {
341 write!(f, "MRF payload length is {actual}, expected {declared}")
342 }
343 Self::PayloadTooLarge => write!(f, "MRF payload exceeds the envelope length limit"),
344 }
345 }
346}
347
348impl std::error::Error for MrfEnvelopeError {}
349
350pub const MRF_V2_NAMESPACE: &str = "config/replication-v2";
351pub const MRF_V2_FILE: &str = "config/replication-v2/mrf.bin";
352pub const MRF_V2_FORMAT: u16 = 2;
353pub const MRF_V2_VERSION: u16 = 2;
354
355const MRF_V2_MAGIC: [u8; 4] = *b"MRF2";
356const MRF_V2_HEADER_LEN: usize = 24;
357const MRF_V2_KNOWN_CAPABILITIES: u64 = 0b1111;
358
359#[derive(Debug, Clone, PartialEq, Eq)]
360pub enum MrfV2Error {
361 InvalidMagic,
362 Truncated,
363 UnsupportedNamespace { namespace: String },
364 UnsupportedFormat { format: u16 },
365 UnsupportedVersion { version: u16 },
366 InvalidVersionRange { version: u16, min_reader_version: u16 },
367 RollbackFenced { min_reader_version: u16, reader_version: u16 },
368 ReservedHeaderBits { bits: u16 },
369 UnknownCapabilities { bits: u64 },
370 MissingCapabilities { required: u64, available: u64 },
371 PayloadLengthMismatch { declared: u32, actual: usize },
372 WriterEnabled,
373}
374
375impl std::fmt::Display for MrfV2Error {
376 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
377 match self {
378 Self::InvalidMagic => write!(f, "invalid MRF v2 magic"),
379 Self::Truncated => write!(f, "truncated MRF v2 envelope"),
380 Self::UnsupportedNamespace { namespace } => write!(f, "unsupported MRF v2 namespace {namespace}"),
381 Self::UnsupportedFormat { format } => write!(f, "unsupported MRF v2 format {format}"),
382 Self::UnsupportedVersion { version } => write!(f, "unsupported MRF v2 version {version}"),
383 Self::InvalidVersionRange {
384 version,
385 min_reader_version,
386 } => {
387 write!(f, "invalid MRF v2 version range: version {version}, minimum reader {min_reader_version}")
388 }
389 Self::RollbackFenced {
390 min_reader_version,
391 reader_version,
392 } => write!(
393 f,
394 "MRF v2 rollback fenced: reader version {reader_version} is below required {min_reader_version}"
395 ),
396 Self::ReservedHeaderBits { bits } => write!(f, "reserved MRF v2 header bits are set: 0x{bits:04x}"),
397 Self::UnknownCapabilities { bits } => write!(f, "unknown MRF v2 capability bits 0x{bits:016x}"),
398 Self::MissingCapabilities { required, available } => {
399 write!(f, "MRF v2 capabilities 0x{available:016x} do not satisfy required 0x{required:016x}")
400 }
401 Self::PayloadLengthMismatch { declared, actual } => {
402 write!(f, "MRF v2 payload is {actual} bytes, expected {declared}")
403 }
404 Self::WriterEnabled => write!(f, "MRF v2 writer must remain dormant"),
405 }
406 }
407}
408
409impl std::error::Error for MrfV2Error {}
410
411#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
412pub struct MrfV2Capabilities(u64);
413
414impl MrfV2Capabilities {
415 pub const fn current() -> Self {
416 Self(MRF_V2_KNOWN_CAPABILITIES)
417 }
418
419 pub const fn empty() -> Self {
420 Self(0)
421 }
422
423 pub const fn bits(self) -> u64 {
424 self.0
425 }
426
427 pub fn from_bits(bits: u64) -> std::result::Result<Self, MrfV2Error> {
428 let unknown = bits & !MRF_V2_KNOWN_CAPABILITIES;
429 if unknown != 0 {
430 return Err(MrfV2Error::UnknownCapabilities { bits: unknown });
431 }
432 Ok(Self(bits))
433 }
434
435 pub const fn supports(self, required: Self) -> bool {
436 self.0 & required.0 == required.0
437 }
438}
439
440#[derive(Debug, Clone, Copy, PartialEq, Eq)]
441pub struct MrfV2Readiness {
442 reader_version: u16,
443 capabilities: MrfV2Capabilities,
444 writer_enabled: bool,
445}
446
447impl MrfV2Readiness {
448 pub const fn dormant() -> Self {
449 Self {
450 reader_version: MRF_V2_VERSION,
451 capabilities: MrfV2Capabilities::current(),
452 writer_enabled: false,
453 }
454 }
455
456 pub const fn new(reader_version: u16, capabilities: MrfV2Capabilities, writer_enabled: bool) -> Self {
457 Self {
458 reader_version,
459 capabilities,
460 writer_enabled,
461 }
462 }
463
464 pub const fn writer_enabled(self) -> bool {
465 self.writer_enabled
466 }
467
468 pub fn reader(self) -> std::result::Result<MrfV2Reader, MrfV2Error> {
469 if self.writer_enabled {
470 return Err(MrfV2Error::WriterEnabled);
471 }
472 if self.reader_version != MRF_V2_VERSION {
473 return Err(MrfV2Error::UnsupportedVersion {
474 version: self.reader_version,
475 });
476 }
477 MrfV2Capabilities::from_bits(self.capabilities.bits())?;
478 Ok(MrfV2Reader { readiness: self })
479 }
480}
481
482#[derive(Debug, Clone, Copy, PartialEq, Eq)]
483pub struct MrfV2Reader {
484 readiness: MrfV2Readiness,
485}
486
487impl MrfV2Reader {
488 pub fn read(self, namespace: &str, data: &[u8]) -> std::result::Result<MrfV2Envelope, MrfV2Error> {
489 if namespace != MRF_V2_NAMESPACE {
490 return Err(MrfV2Error::UnsupportedNamespace {
491 namespace: namespace.to_string(),
492 });
493 }
494 if data.len() < MRF_V2_HEADER_LEN {
495 return Err(MrfV2Error::Truncated);
496 }
497 if data[..4] != MRF_V2_MAGIC {
498 return Err(MrfV2Error::InvalidMagic);
499 }
500 let format = LittleEndian::read_u16(&data[4..6]);
501 if format != MRF_V2_FORMAT {
502 return Err(MrfV2Error::UnsupportedFormat { format });
503 }
504 let version = LittleEndian::read_u16(&data[6..8]);
505 if version != MRF_V2_VERSION || version != self.readiness.reader_version {
506 return Err(MrfV2Error::UnsupportedVersion { version });
507 }
508 let min_reader_version = LittleEndian::read_u16(&data[8..10]);
509 if min_reader_version > self.readiness.reader_version {
510 return Err(MrfV2Error::RollbackFenced {
511 min_reader_version,
512 reader_version: self.readiness.reader_version,
513 });
514 }
515 if min_reader_version > version {
516 return Err(MrfV2Error::InvalidVersionRange {
517 version,
518 min_reader_version,
519 });
520 }
521 let reserved = LittleEndian::read_u16(&data[10..12]);
522 if reserved != 0 {
523 return Err(MrfV2Error::ReservedHeaderBits { bits: reserved });
524 }
525 let capabilities = MrfV2Capabilities::from_bits(LittleEndian::read_u64(&data[12..20]))?;
526 if !self.readiness.capabilities.supports(capabilities) {
527 return Err(MrfV2Error::MissingCapabilities {
528 required: capabilities.bits(),
529 available: self.readiness.capabilities.bits(),
530 });
531 }
532 let payload_len = LittleEndian::read_u32(&data[20..24]);
533 let actual = data.len() - MRF_V2_HEADER_LEN;
534 if usize::try_from(payload_len).map_err(|_| MrfV2Error::PayloadLengthMismatch {
535 declared: payload_len,
536 actual,
537 })? != actual
538 {
539 return Err(MrfV2Error::PayloadLengthMismatch {
540 declared: payload_len,
541 actual,
542 });
543 }
544 Ok(MrfV2Envelope {
545 version,
546 min_reader_version,
547 capabilities,
548 payload: data[MRF_V2_HEADER_LEN..].to_vec(),
549 })
550 }
551}
552
553#[derive(Debug, Clone, PartialEq, Eq)]
554pub struct MrfV2Envelope {
555 version: u16,
556 min_reader_version: u16,
557 capabilities: MrfV2Capabilities,
558 payload: Vec<u8>,
559}
560
561impl MrfV2Envelope {
562 pub const fn version(&self) -> u16 {
563 self.version
564 }
565
566 pub const fn min_reader_version(&self) -> u16 {
567 self.min_reader_version
568 }
569
570 pub const fn capabilities(&self) -> MrfV2Capabilities {
571 self.capabilities
572 }
573
574 pub fn payload(&self) -> &[u8] {
575 &self.payload
576 }
577}
578pub fn encode_mrf_file(entries: &[MrfReplicateEntry]) -> Result<Vec<u8>> {
579 let payload = rmp_serde::to_vec_named(entries).map_err(|e| ResyncStateError::Other(e.to_string()))?;
580 let mut data = Vec::with_capacity(4 + payload.len());
581 let mut fmt = [0u8; 2];
582 LittleEndian::write_u16(&mut fmt, MRF_META_FORMAT);
583 data.extend_from_slice(&fmt);
584 let mut ver = [0u8; 2];
585 LittleEndian::write_u16(&mut ver, MRF_META_VERSION);
586 data.extend_from_slice(&ver);
587 data.extend_from_slice(&payload);
588 Ok(data)
589}
590
591pub fn decode_mrf_file(data: &[u8]) -> Result<Vec<MrfReplicateEntry>> {
592 if data.len() <= 4 {
593 return Err(ResyncStateError::CorruptedFormat);
594 }
595 let mut fmt = [0u8; 2];
596 fmt.copy_from_slice(&data[0..2]);
597 if LittleEndian::read_u16(&fmt) != MRF_META_FORMAT {
598 return Err(ResyncStateError::CorruptedFormat);
599 }
600 let mut ver = [0u8; 2];
601 ver.copy_from_slice(&data[2..4]);
602 if LittleEndian::read_u16(&ver) != MRF_META_VERSION {
603 return Err(ResyncStateError::CorruptedFormat);
604 }
605 rmp_serde::from_slice(&data[4..]).map_err(|e| ResyncStateError::Other(e.to_string()))
606}
607
608#[cfg(test)]
609mod tests {
610 use super::*;
611 use std::collections::HashMap;
612 use uuid::Uuid;
613
614 const ENVELOPE_FIXTURE: &[u8] = &[
617 b'M', b'R', b'F', b'E', 1, 0, 1, 0, 1, 0, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 2, 3,
618 ];
619
620 const PRE_TARGET_MARKER_IDS_ENVELOPE_FIXTURE: &[u8] = &[
622 b'M', b'R', b'F', b'E', 1, 0, 1, 0, 1, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 2, 3,
623 ];
624
625 #[test]
626 fn mrf_file_round_trips_object_metadata_and_delete_entries() {
627 let obj_vid = Uuid::new_v4();
628 let del_vid = Uuid::new_v4();
629 let entries = vec![
630 MrfReplicateEntry {
631 bucket: "bucket-a".to_string(),
632 object: "metadata-a".to_string(),
633 version_id: Some(obj_vid),
634 retry_count: 1,
635 size: 1024,
636 op: MrfOpKind::Metadata,
637 force_delete_id: None,
638 force_delete_generation: None,
639 force_delete_local_commit: false,
640 force_delete: false,
641 delete_marker_version_id: None,
642 delete_marker: false,
643 delete_marker_mtime: None,
644 target_delete_marker_version_ids: HashMap::new(),
645 target_delete_marker_version_ids_corrupt: false,
646 target_arns: vec!["arn:target-a".to_string()],
647 },
648 MrfReplicateEntry {
649 bucket: "bucket-a".to_string(),
650 object: "object-a".to_string(),
651 version_id: Some(obj_vid),
652 retry_count: 2,
653 size: 1024,
654 op: MrfOpKind::Object,
655 force_delete_id: None,
656 force_delete_generation: None,
657 force_delete_local_commit: false,
658 force_delete: false,
659 delete_marker_version_id: None,
660 delete_marker: false,
661 delete_marker_mtime: None,
662 target_delete_marker_version_ids: HashMap::new(),
663 target_delete_marker_version_ids_corrupt: false,
664 target_arns: vec!["arn:target-a".to_string(), "arn:target-b".to_string()],
665 },
666 MrfReplicateEntry {
667 bucket: "bucket-a".to_string(),
668 object: "delete-a".to_string(),
669 version_id: None,
670 retry_count: 0,
671 size: 0,
672 op: MrfOpKind::Delete,
673 force_delete_id: None,
674 force_delete_generation: None,
675 force_delete_local_commit: false,
676 force_delete: true,
677 delete_marker_version_id: Some(del_vid),
678 delete_marker: true,
679 delete_marker_mtime: Some(1_705_312_200_123_456_789),
680 target_delete_marker_version_ids: HashMap::from([
681 ("arn:target-a".to_string(), "remote-marker-a".to_string()),
682 ("arn:target-b".to_string(), "remote-marker-b".to_string()),
683 ]),
684 target_delete_marker_version_ids_corrupt: false,
685 target_arns: vec!["arn:target-a".to_string()],
686 },
687 ];
688
689 let encoded = encode_mrf_file(&entries).expect("mrf file should encode");
690 let decoded = decode_mrf_file(&encoded).expect("mrf file should decode");
691
692 assert_eq!(decoded.len(), 3);
693 assert_eq!(decoded[0].version_id, Some(obj_vid));
694 assert_eq!(decoded[0].op, MrfOpKind::Metadata);
695 assert_eq!(decoded[0].target_arns, vec!["arn:target-a".to_string()]);
696 assert_eq!(decoded[0].delete_marker_mtime, None);
697 assert!(!decoded[0].force_delete);
698 assert_eq!(decoded[1].op, MrfOpKind::Object);
699 assert!(!decoded[1].force_delete);
700 assert_eq!(decoded[1].target_arns, vec!["arn:target-a".to_string(), "arn:target-b".to_string()]);
701 assert_eq!(decoded[1].delete_marker_mtime, None);
702 assert_eq!(decoded[2].delete_marker_version_id, Some(del_vid));
703 assert_eq!(decoded[2].op, MrfOpKind::Delete);
704 assert!(decoded[2].force_delete);
705 assert_eq!(decoded[2].target_arns, vec!["arn:target-a".to_string()]);
706 assert!(decoded[2].delete_marker);
707 assert_eq!(
708 decoded[2].delete_marker_mtime,
709 Some(1_705_312_200_123_456_789),
710 "delete-marker mtime must survive the MRF disk round-trip"
711 );
712 assert!(decoded[0].target_delete_marker_version_ids.is_empty());
713 assert!(decoded[1].target_delete_marker_version_ids.is_empty());
714 assert_eq!(
715 decoded[2].target_delete_marker_version_ids,
716 HashMap::from([
717 ("arn:target-a".to_string(), "remote-marker-a".to_string()),
718 ("arn:target-b".to_string(), "remote-marker-b".to_string()),
719 ]),
720 "target-assigned marker version ids must survive the MRF disk round-trip (backlog#2290)"
721 );
722 assert!(!decoded[2].target_delete_marker_version_ids_corrupt);
723 }
724
725 #[test]
729 fn mrf_file_round_trips_target_marker_ids_corrupt_flag_and_skips_empty_keys() {
730 let corrupt = MrfReplicateEntry {
731 bucket: "bucket-a".to_string(),
732 object: "delete-a".to_string(),
733 op: MrfOpKind::Delete,
734 delete_marker: true,
735 delete_marker_version_id: Some(Uuid::new_v4()),
736 target_delete_marker_version_ids_corrupt: true,
737 target_arns: vec!["arn:target-a".to_string()],
738 ..Default::default()
739 };
740 let decoded = decode_mrf_file(&encode_mrf_file(std::slice::from_ref(&corrupt)).expect("mrf file should encode"))
741 .expect("mrf file should decode");
742 assert_eq!(decoded, vec![corrupt]);
743 assert!(decoded[0].target_delete_marker_version_ids_corrupt);
744
745 let plain = MrfReplicateEntry {
746 bucket: "bucket-a".to_string(),
747 object: "delete-a".to_string(),
748 op: MrfOpKind::Delete,
749 delete_marker: true,
750 target_arns: vec!["arn:target-a".to_string()],
751 ..Default::default()
752 };
753 let encoded = encode_mrf_file(std::slice::from_ref(&plain)).expect("mrf file should encode");
754 let payload = String::from_utf8_lossy(&encoded);
755 assert!(
756 !payload.contains("targetDeleteMarkerVersionIDs"),
757 "an entry without recorded ids must not grow the new keys: {payload}"
758 );
759 assert_eq!(decode_mrf_file(&encoded).expect("mrf file should decode"), vec![plain]);
760 }
761
762 #[test]
763 fn mrf_legacy_file_without_op_decodes_as_object() {
764 let mut payload = Vec::new();
765 rmp::encode::write_array_len(&mut payload, 1).expect("array len should encode");
766 rmp::encode::write_map_len(&mut payload, 4).expect("map len should encode");
767 rmp::encode::write_str(&mut payload, "bucket").expect("bucket key should encode");
768 rmp::encode::write_str(&mut payload, "old-bucket").expect("bucket value should encode");
769 rmp::encode::write_str(&mut payload, "object").expect("object key should encode");
770 rmp::encode::write_str(&mut payload, "old-key").expect("object value should encode");
771 rmp::encode::write_str(&mut payload, "retryCount").expect("retry key should encode");
772 rmp::encode::write_i32(&mut payload, 2).expect("retry value should encode");
773 rmp::encode::write_str(&mut payload, "size").expect("size key should encode");
774 rmp::encode::write_i64(&mut payload, 100).expect("size value should encode");
775
776 let mut data = Vec::with_capacity(4 + payload.len());
777 data.extend_from_slice(&MRF_META_FORMAT.to_le_bytes());
778 data.extend_from_slice(&MRF_META_VERSION.to_le_bytes());
779 data.extend_from_slice(&payload);
780
781 let decoded = decode_mrf_file(&data).expect("legacy mrf file should decode");
782
783 assert_eq!(decoded.len(), 1);
784 assert_eq!(decoded[0].bucket, "old-bucket");
785 assert_eq!(decoded[0].object, "old-key");
786 assert_eq!(decoded[0].retry_count, 2);
787 assert_eq!(decoded[0].size, 100);
788 assert_eq!(decoded[0].op, MrfOpKind::Object);
789 assert!(decoded[0].target_arns.is_empty());
790 assert!(!decoded[0].force_delete);
791 assert_eq!(decoded[0].delete_marker_mtime, None);
794 assert!(decoded[0].target_delete_marker_version_ids.is_empty());
797 assert!(!decoded[0].target_delete_marker_version_ids_corrupt);
798 }
799
800 #[test]
804 fn mrf_pre_target_marker_ids_delete_entry_decodes_with_empty_map() {
805 let marker_version_id = Uuid::new_v4();
806 let mut payload = Vec::new();
807 rmp::encode::write_array_len(&mut payload, 1).expect("array len should encode");
808 rmp::encode::write_map_len(&mut payload, 9).expect("map len should encode");
809 rmp::encode::write_str(&mut payload, "bucket").expect("bucket key should encode");
810 rmp::encode::write_str(&mut payload, "old-bucket").expect("bucket value should encode");
811 rmp::encode::write_str(&mut payload, "object").expect("object key should encode");
812 rmp::encode::write_str(&mut payload, "old-key").expect("object value should encode");
813 rmp::encode::write_str(&mut payload, "retryCount").expect("retry key should encode");
814 rmp::encode::write_i32(&mut payload, 0).expect("retry value should encode");
815 rmp::encode::write_str(&mut payload, "size").expect("size key should encode");
816 rmp::encode::write_i64(&mut payload, 0).expect("size value should encode");
817 rmp::encode::write_str(&mut payload, "op").expect("op key should encode");
818 rmp::encode::write_str(&mut payload, "delete").expect("op value should encode");
819 rmp::encode::write_str(&mut payload, "forceDelete").expect("forceDelete key should encode");
820 rmp::encode::write_bool(&mut payload, false).expect("forceDelete value should encode");
821 rmp::encode::write_str(&mut payload, "deleteMarkerVersionID").expect("marker id key should encode");
822 rmp::encode::write_bin(&mut payload, marker_version_id.as_bytes()).expect("marker id value should encode");
824 rmp::encode::write_str(&mut payload, "deleteMarker").expect("deleteMarker key should encode");
825 rmp::encode::write_bool(&mut payload, true).expect("deleteMarker value should encode");
826 rmp::encode::write_str(&mut payload, "targetARNs").expect("targetARNs key should encode");
827 rmp::encode::write_array_len(&mut payload, 1).expect("targetARNs len should encode");
828 rmp::encode::write_str(&mut payload, "arn:target-a").expect("targetARNs value should encode");
829
830 let mut data = Vec::with_capacity(4 + payload.len());
831 data.extend_from_slice(&MRF_META_FORMAT.to_le_bytes());
832 data.extend_from_slice(&MRF_META_VERSION.to_le_bytes());
833 data.extend_from_slice(&payload);
834
835 let decoded = decode_mrf_file(&data).expect("pre-#2290 delete-marker entry should decode");
836
837 assert_eq!(decoded.len(), 1);
838 assert_eq!(decoded[0].op, MrfOpKind::Delete);
839 assert!(decoded[0].delete_marker);
840 assert_eq!(decoded[0].delete_marker_version_id, Some(marker_version_id));
841 assert_eq!(decoded[0].target_arns, vec!["arn:target-a".to_string()]);
842 assert!(decoded[0].target_delete_marker_version_ids.is_empty());
843 assert!(!decoded[0].target_delete_marker_version_ids_corrupt);
844 }
845
846 #[test]
851 fn envelope_target_marker_ids_capability_is_fenced_and_backward_compatible() {
852 assert!(MrfCapabilities::current().contains(MrfCapability::TargetDeleteMarkerVersionIds));
853 assert_eq!(MrfCapabilities::with(MrfCapability::TargetDeleteMarkerVersionIds).bits(), 1 << 4);
854
855 let legacy = MrfEnvelope::decode(PRE_TARGET_MARKER_IDS_ENVELOPE_FIXTURE, MrfProtocolCapabilities::current())
857 .expect("pre-#2290 envelope should decode");
858 assert_eq!(legacy.protocol().capabilities().bits(), 15);
859 assert!(
860 !legacy
861 .protocol()
862 .capabilities()
863 .contains(MrfCapability::TargetDeleteMarkerVersionIds)
864 );
865 assert_eq!(legacy.payload(), &[1, 2, 3]);
866
867 let pre_2290_reader = MrfProtocolCapabilities::new(1, 1, MrfCapabilities::from_bits(15).expect("known bits"));
869 assert_eq!(
870 MrfEnvelope::decode(ENVELOPE_FIXTURE, pre_2290_reader),
871 Err(MrfEnvelopeError::MissingCapabilities {
872 required: 31,
873 available: 15,
874 })
875 );
876
877 let negotiated = MrfProtocolCapabilities::current()
879 .negotiate(pre_2290_reader)
880 .expect("negotiation with a pre-#2290 peer should succeed");
881 assert!(
882 !negotiated
883 .capabilities()
884 .contains(MrfCapability::TargetDeleteMarkerVersionIds)
885 );
886 assert!(negotiated.capabilities().contains(MrfCapability::DeleteMarkerMtime));
887 }
888
889 #[test]
890 fn mrf_file_defaults_missing_force_delete_to_false() {
891 let mut payload = Vec::new();
892 rmp::encode::write_array_len(&mut payload, 1).expect("array len should encode");
893 rmp::encode::write_map_len(&mut payload, 5).expect("map len should encode");
894 rmp::encode::write_str(&mut payload, "bucket").expect("bucket key should encode");
895 rmp::encode::write_str(&mut payload, "old-bucket").expect("bucket value should encode");
896 rmp::encode::write_str(&mut payload, "object").expect("object key should encode");
897 rmp::encode::write_str(&mut payload, "old-key").expect("object value should encode");
898 rmp::encode::write_str(&mut payload, "retryCount").expect("retry key should encode");
899 rmp::encode::write_i32(&mut payload, 1).expect("retry value should encode");
900 rmp::encode::write_str(&mut payload, "size").expect("size key should encode");
901 rmp::encode::write_i64(&mut payload, 0).expect("size value should encode");
902 rmp::encode::write_str(&mut payload, "op").expect("op key should encode");
903 rmp::encode::write_str(&mut payload, "delete").expect("op value should encode");
904
905 let mut data = Vec::with_capacity(4 + payload.len());
906 data.extend_from_slice(&MRF_META_FORMAT.to_le_bytes());
907 data.extend_from_slice(&MRF_META_VERSION.to_le_bytes());
908 data.extend_from_slice(&payload);
909
910 let decoded = decode_mrf_file(&data).expect("MRF payload should decode");
911
912 assert_eq!(decoded[0].op, MrfOpKind::Delete);
913 assert!(!decoded[0].force_delete);
914 }
915
916 #[test]
917 fn mrf_file_rejects_invalid_header() {
918 let mut data = Vec::new();
919 data.extend_from_slice(&2u16.to_le_bytes());
920 data.extend_from_slice(&MRF_META_VERSION.to_le_bytes());
921 data.push(0x90);
922
923 assert!(matches!(decode_mrf_file(&data), Err(ResyncStateError::CorruptedFormat)));
924 }
925
926 #[test]
927 fn envelope_fixture_is_stable_and_round_trips() {
928 let envelope =
929 MrfEnvelope::new(MrfProtocolCapabilities::current(), vec![1, 2, 3]).expect("current MRF envelope should be valid");
930 assert_eq!(envelope.encode().expect("envelope should encode"), ENVELOPE_FIXTURE);
931 let decoded = MrfEnvelope::decode(ENVELOPE_FIXTURE, MrfProtocolCapabilities::current()).expect("fixture should decode");
932 assert_eq!(decoded.protocol(), MrfProtocolCapabilities::current());
933 assert_eq!(decoded.payload(), &[1, 2, 3]);
934 }
935
936 #[test]
937 fn envelope_accepts_a_forward_compatible_writer_version() {
938 let mut version = ENVELOPE_FIXTURE.to_vec();
939 version[6..8].copy_from_slice(&2u16.to_le_bytes());
940 let decoded =
941 MrfEnvelope::decode(&version, MrfProtocolCapabilities::current()).expect("compatible v2 envelope should decode");
942 assert_eq!(decoded.protocol().version(), 2);
943 assert_eq!(decoded.protocol().min_reader_version(), 1);
944
945 let mut fenced = version;
946 fenced[8..10].copy_from_slice(&2u16.to_le_bytes());
947 assert_eq!(
948 MrfEnvelope::decode(&fenced, MrfProtocolCapabilities::current()),
949 Err(MrfEnvelopeError::RollbackFenced {
950 min_reader_version: 2,
951 supported_version: 1,
952 })
953 );
954 }
955
956 #[test]
957 fn envelope_rejects_unknown_capability_bits() {
958 let mut capabilities = ENVELOPE_FIXTURE.to_vec();
959 capabilities[12..20].copy_from_slice(&(1u64 << 63).to_le_bytes());
960
961 assert_eq!(
962 MrfEnvelope::decode(&capabilities, MrfProtocolCapabilities::current()),
963 Err(MrfEnvelopeError::UnknownCapabilities { bits: 1u64 << 63 })
964 );
965
966 let mut reserved = ENVELOPE_FIXTURE.to_vec();
967 reserved[10..12].copy_from_slice(&1u16.to_le_bytes());
968 assert_eq!(
969 MrfEnvelope::decode(&reserved, MrfProtocolCapabilities::current()),
970 Err(MrfEnvelopeError::ReservedHeaderBits { bits: 1 })
971 );
972
973 let mut legacy = ENVELOPE_FIXTURE.to_vec();
974 legacy[6..8].copy_from_slice(&0u16.to_le_bytes());
975 assert_eq!(
976 MrfEnvelope::decode(&legacy, MrfProtocolCapabilities::current()),
977 Err(MrfEnvelopeError::UnsupportedVersion { version: 0 })
978 );
979 }
980
981 #[test]
982 fn envelope_rejects_rollback_and_missing_capabilities() {
983 let mut rollback = ENVELOPE_FIXTURE.to_vec();
984 rollback[8..10].copy_from_slice(&2u16.to_le_bytes());
985 assert_eq!(
986 MrfEnvelope::decode(&rollback, MrfProtocolCapabilities::current()),
987 Err(MrfEnvelopeError::RollbackFenced {
988 min_reader_version: 2,
989 supported_version: 1,
990 })
991 );
992
993 let required = MrfCapabilities::with(MrfCapability::TargetArns);
994 let envelope =
995 MrfEnvelope::new(MrfProtocolCapabilities::new(1, 1, required), Vec::new()).expect("known capability should be valid");
996 let encoded = envelope.encode().expect("envelope should encode");
997 assert_eq!(
998 MrfEnvelope::decode(&encoded, MrfProtocolCapabilities::new(1, 1, MrfCapabilities::empty())),
999 Err(MrfEnvelopeError::MissingCapabilities {
1000 required: required.bits(),
1001 available: 0,
1002 })
1003 );
1004 }
1005
1006 #[test]
1007 fn protocol_negotiation_fences_rollback() {
1008 let current = MrfProtocolCapabilities::current();
1009 let rollback = MrfProtocolCapabilities::new(1, 2, MrfCapabilities::current());
1010 assert_eq!(
1011 current.negotiate(rollback),
1012 Err(MrfEnvelopeError::InvalidVersionRange {
1013 version: 1,
1014 min_reader_version: 2,
1015 })
1016 );
1017 }
1018
1019 #[test]
1020 fn protocol_negotiation_rejects_invalid_local_version_range() {
1021 let invalid = MrfProtocolCapabilities::new(1, 2, MrfCapabilities::current());
1022 assert_eq!(
1023 invalid.negotiate(MrfProtocolCapabilities::current()),
1024 Err(MrfEnvelopeError::InvalidVersionRange {
1025 version: 1,
1026 min_reader_version: 2,
1027 })
1028 );
1029 }
1030
1031 #[test]
1032 fn protocol_negotiation_intersects_capabilities() {
1033 let local = MrfProtocolCapabilities::new(1, 1, MrfCapabilities::with(MrfCapability::TargetArns));
1034 let peer = MrfProtocolCapabilities::new(1, 1, MrfCapabilities::with(MrfCapability::ForceDelete));
1035 let negotiated = local.negotiate(peer).expect("same-version peers should negotiate");
1036 assert_eq!(negotiated.capabilities(), MrfCapabilities::empty());
1037 }
1038
1039 #[test]
1040 fn protocol_negotiation_accepts_a_forward_compatible_peer() {
1041 let reader = MrfProtocolCapabilities::current();
1042 let writer = MrfProtocolCapabilities::new(2, 1, MrfCapabilities::current());
1043 let negotiated = reader
1044 .negotiate(writer)
1045 .expect("v1 reader should negotiate with a compatible v2 writer");
1046 assert_eq!(negotiated.version(), 1);
1047 assert_eq!(negotiated.min_reader_version(), 1);
1048 }
1049
1050 #[test]
1051 fn v1_file_contract_and_v2_namespace_remain_separate() {
1052 assert_eq!(encode_mrf_file(&[]).expect("v1 empty file should encode"), vec![1, 0, 1, 0, 0x90]);
1053 assert_eq!(MRF_V2_FILE, "config/replication-v2/mrf.bin");
1054 assert_ne!(MRF_V2_FILE, "config/replication/mrf.bin");
1055 }
1056
1057 #[test]
1058 fn dormant_v2_reader_accepts_stable_fixture() {
1059 let fixture = [
1060 b'M', b'R', b'F', b'2', 2, 0, 2, 0, 2, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 2, 3,
1061 ];
1062 let readiness = MrfV2Readiness::dormant();
1063 assert!(!readiness.writer_enabled());
1064 let envelope = readiness
1065 .reader()
1066 .expect("dormant readiness should expose the reader")
1067 .read(MRF_V2_NAMESPACE, &fixture)
1068 .expect("v2 fixture should decode");
1069 assert_eq!(envelope.version(), MRF_V2_VERSION);
1070 assert_eq!(envelope.min_reader_version(), MRF_V2_VERSION);
1071 assert_eq!(envelope.capabilities(), MrfV2Capabilities::current());
1072 assert_eq!(envelope.payload(), &[1, 2, 3]);
1073 }
1074
1075 #[test]
1076 fn v2_reader_rejects_wrong_namespace_version_capability_and_rollback() {
1077 let fixture = [
1078 b'M', b'R', b'F', b'2', 2, 0, 2, 0, 2, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 2, 3,
1079 ];
1080 let reader = MrfV2Readiness::dormant().reader().expect("dormant reader should initialize");
1081 assert!(matches!(
1082 reader.read("config/replication/mrf.bin", &fixture),
1083 Err(MrfV2Error::UnsupportedNamespace { .. })
1084 ));
1085
1086 let mut version = fixture;
1087 version[6..8].copy_from_slice(&1u16.to_le_bytes());
1088 assert_eq!(
1089 reader.read(MRF_V2_NAMESPACE, &version),
1090 Err(MrfV2Error::UnsupportedVersion { version: 1 })
1091 );
1092
1093 let mut capabilities = fixture;
1094 capabilities[12..20].copy_from_slice(&(1u64 << 63).to_le_bytes());
1095 assert_eq!(
1096 reader.read(MRF_V2_NAMESPACE, &capabilities),
1097 Err(MrfV2Error::UnknownCapabilities { bits: 1u64 << 63 })
1098 );
1099
1100 let mut rollback = fixture;
1101 rollback[8..10].copy_from_slice(&3u16.to_le_bytes());
1102 assert_eq!(
1103 reader.read(MRF_V2_NAMESPACE, &rollback),
1104 Err(MrfV2Error::RollbackFenced {
1105 min_reader_version: 3,
1106 reader_version: 2,
1107 })
1108 );
1109 }
1110
1111 #[test]
1112 fn v2_readiness_rejects_writer_enablement_and_missing_capabilities() {
1113 assert_eq!(
1114 MrfV2Readiness::new(2, MrfV2Capabilities::current(), true).reader(),
1115 Err(MrfV2Error::WriterEnabled)
1116 );
1117
1118 let fixture = [
1119 b'M', b'R', b'F', b'2', 2, 0, 2, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 2, 3,
1120 ];
1121 let reader = MrfV2Readiness::new(2, MrfV2Capabilities::empty(), false)
1122 .reader()
1123 .expect("readiness with valid empty capabilities should initialize");
1124 assert_eq!(
1125 reader.read(MRF_V2_NAMESPACE, &fixture),
1126 Err(MrfV2Error::MissingCapabilities {
1127 required: 1,
1128 available: 0,
1129 })
1130 );
1131 }
1132}