Line data Source code
1 : //! Every image of a certain timeline from [`crate::tenant::Tenant`]
2 : //! has a metadata that needs to be stored persistently.
3 : //!
4 : //! Later, the file gets used in [`remote_timeline_client`] as a part of
5 : //! external storage import and export operations.
6 : //!
7 : //! The module contains all structs and related helper methods related to timeline metadata.
8 : //!
9 : //! [`remote_timeline_client`]: super::remote_timeline_client
10 :
11 : use anyhow::ensure;
12 : use serde::{de::Error, Deserialize, Serialize, Serializer};
13 : use utils::bin_ser::SerializeError;
14 : use utils::{bin_ser::BeSer, id::TimelineId, lsn::Lsn};
15 :
16 : /// Use special format number to enable backward compatibility.
17 : const METADATA_FORMAT_VERSION: u16 = 4;
18 :
19 : /// Previous supported format versions.
20 : const METADATA_OLD_FORMAT_VERSION: u16 = 3;
21 :
22 : /// We assume that a write of up to METADATA_MAX_SIZE bytes is atomic.
23 : ///
24 : /// This is the same assumption that PostgreSQL makes with the control file,
25 : /// see PG_CONTROL_MAX_SAFE_SIZE
26 : const METADATA_MAX_SIZE: usize = 512;
27 :
28 : /// Metadata stored on disk for each timeline
29 : ///
30 : /// The fields correspond to the values we hold in memory, in Timeline.
31 1820 : #[derive(Debug, Clone, PartialEq, Eq)]
32 : pub struct TimelineMetadata {
33 : hdr: TimelineMetadataHeader,
34 : body: TimelineMetadataBodyV2,
35 : }
36 :
37 1820 : #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
38 : struct TimelineMetadataHeader {
39 : checksum: u32, // CRC of serialized metadata body
40 : size: u16, // size of serialized metadata
41 : format_version: u16, // metadata format version (used for compatibility checks)
42 : }
43 : const METADATA_HDR_SIZE: usize = std::mem::size_of::<TimelineMetadataHeader>();
44 :
45 1820 : #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
46 : struct TimelineMetadataBodyV2 {
47 : disk_consistent_lsn: Lsn,
48 : // This is only set if we know it. We track it in memory when the page
49 : // server is running, but we only track the value corresponding to
50 : // 'last_record_lsn', not 'disk_consistent_lsn' which can lag behind by a
51 : // lot. We only store it in the metadata file when we flush *all* the
52 : // in-memory data so that 'last_record_lsn' is the same as
53 : // 'disk_consistent_lsn'. That's OK, because after page server restart, as
54 : // soon as we reprocess at least one record, we will have a valid
55 : // 'prev_record_lsn' value in memory again. This is only really needed when
56 : // doing a clean shutdown, so that there is no more WAL beyond
57 : // 'disk_consistent_lsn'
58 : prev_record_lsn: Option<Lsn>,
59 : ancestor_timeline: Option<TimelineId>,
60 : ancestor_lsn: Lsn,
61 : latest_gc_cutoff_lsn: Lsn,
62 : initdb_lsn: Lsn,
63 : pg_version: u32,
64 : }
65 :
66 4 : #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
67 : struct TimelineMetadataBodyV1 {
68 : disk_consistent_lsn: Lsn,
69 : // This is only set if we know it. We track it in memory when the page
70 : // server is running, but we only track the value corresponding to
71 : // 'last_record_lsn', not 'disk_consistent_lsn' which can lag behind by a
72 : // lot. We only store it in the metadata file when we flush *all* the
73 : // in-memory data so that 'last_record_lsn' is the same as
74 : // 'disk_consistent_lsn'. That's OK, because after page server restart, as
75 : // soon as we reprocess at least one record, we will have a valid
76 : // 'prev_record_lsn' value in memory again. This is only really needed when
77 : // doing a clean shutdown, so that there is no more WAL beyond
78 : // 'disk_consistent_lsn'
79 : prev_record_lsn: Option<Lsn>,
80 : ancestor_timeline: Option<TimelineId>,
81 : ancestor_lsn: Lsn,
82 : latest_gc_cutoff_lsn: Lsn,
83 : initdb_lsn: Lsn,
84 : }
85 :
86 : impl TimelineMetadata {
87 836 : pub fn new(
88 836 : disk_consistent_lsn: Lsn,
89 836 : prev_record_lsn: Option<Lsn>,
90 836 : ancestor_timeline: Option<TimelineId>,
91 836 : ancestor_lsn: Lsn,
92 836 : latest_gc_cutoff_lsn: Lsn,
93 836 : initdb_lsn: Lsn,
94 836 : pg_version: u32,
95 836 : ) -> Self {
96 836 : Self {
97 836 : hdr: TimelineMetadataHeader {
98 836 : checksum: 0,
99 836 : size: 0,
100 836 : format_version: METADATA_FORMAT_VERSION,
101 836 : },
102 836 : body: TimelineMetadataBodyV2 {
103 836 : disk_consistent_lsn,
104 836 : prev_record_lsn,
105 836 : ancestor_timeline,
106 836 : ancestor_lsn,
107 836 : latest_gc_cutoff_lsn,
108 836 : initdb_lsn,
109 836 : pg_version,
110 836 : },
111 836 : }
112 836 : }
113 :
114 2 : fn upgrade_timeline_metadata(metadata_bytes: &[u8]) -> anyhow::Result<Self> {
115 2 : let mut hdr = TimelineMetadataHeader::des(&metadata_bytes[0..METADATA_HDR_SIZE])?;
116 :
117 : // backward compatible only up to this version
118 2 : ensure!(
119 2 : hdr.format_version == METADATA_OLD_FORMAT_VERSION,
120 0 : "unsupported metadata format version {}",
121 : hdr.format_version
122 : );
123 :
124 2 : let metadata_size = hdr.size as usize;
125 :
126 2 : let body: TimelineMetadataBodyV1 =
127 2 : TimelineMetadataBodyV1::des(&metadata_bytes[METADATA_HDR_SIZE..metadata_size])?;
128 :
129 2 : let body = TimelineMetadataBodyV2 {
130 2 : disk_consistent_lsn: body.disk_consistent_lsn,
131 2 : prev_record_lsn: body.prev_record_lsn,
132 2 : ancestor_timeline: body.ancestor_timeline,
133 2 : ancestor_lsn: body.ancestor_lsn,
134 2 : latest_gc_cutoff_lsn: body.latest_gc_cutoff_lsn,
135 2 : initdb_lsn: body.initdb_lsn,
136 2 : pg_version: 14, // All timelines created before this version had pg_version 14
137 2 : };
138 2 :
139 2 : hdr.format_version = METADATA_FORMAT_VERSION;
140 2 :
141 2 : Ok(Self { hdr, body })
142 2 : }
143 :
144 62 : pub fn from_bytes(metadata_bytes: &[u8]) -> anyhow::Result<Self> {
145 62 : ensure!(
146 62 : metadata_bytes.len() == METADATA_MAX_SIZE,
147 0 : "metadata bytes size is wrong"
148 : );
149 62 : let hdr = TimelineMetadataHeader::des(&metadata_bytes[0..METADATA_HDR_SIZE])?;
150 :
151 62 : let metadata_size = hdr.size as usize;
152 62 : ensure!(
153 62 : metadata_size <= METADATA_MAX_SIZE,
154 0 : "corrupted metadata file"
155 : );
156 62 : let calculated_checksum = crc32c::crc32c(&metadata_bytes[METADATA_HDR_SIZE..metadata_size]);
157 62 : ensure!(
158 62 : hdr.checksum == calculated_checksum,
159 0 : "metadata checksum mismatch"
160 : );
161 :
162 62 : if hdr.format_version != METADATA_FORMAT_VERSION {
163 : // If metadata has the old format,
164 : // upgrade it and return the result
165 2 : TimelineMetadata::upgrade_timeline_metadata(metadata_bytes)
166 : } else {
167 60 : let body =
168 60 : TimelineMetadataBodyV2::des(&metadata_bytes[METADATA_HDR_SIZE..metadata_size])?;
169 60 : ensure!(
170 60 : body.disk_consistent_lsn.is_aligned(),
171 0 : "disk_consistent_lsn is not aligned"
172 : );
173 60 : Ok(TimelineMetadata { hdr, body })
174 : }
175 62 : }
176 :
177 785 : pub fn to_bytes(&self) -> Result<Vec<u8>, SerializeError> {
178 785 : let body_bytes = self.body.ser()?;
179 785 : let metadata_size = METADATA_HDR_SIZE + body_bytes.len();
180 785 : let hdr = TimelineMetadataHeader {
181 785 : size: metadata_size as u16,
182 785 : format_version: METADATA_FORMAT_VERSION,
183 785 : checksum: crc32c::crc32c(&body_bytes),
184 785 : };
185 785 : let hdr_bytes = hdr.ser()?;
186 785 : let mut metadata_bytes = vec![0u8; METADATA_MAX_SIZE];
187 785 : metadata_bytes[0..METADATA_HDR_SIZE].copy_from_slice(&hdr_bytes);
188 785 : metadata_bytes[METADATA_HDR_SIZE..metadata_size].copy_from_slice(&body_bytes);
189 785 : Ok(metadata_bytes)
190 785 : }
191 :
192 : /// [`Lsn`] that corresponds to the corresponding timeline directory
193 : /// contents, stored locally in the pageserver workdir.
194 1100 : pub fn disk_consistent_lsn(&self) -> Lsn {
195 1100 : self.body.disk_consistent_lsn
196 1100 : }
197 :
198 296 : pub fn prev_record_lsn(&self) -> Option<Lsn> {
199 296 : self.body.prev_record_lsn
200 296 : }
201 :
202 308 : pub fn ancestor_timeline(&self) -> Option<TimelineId> {
203 308 : self.body.ancestor_timeline
204 308 : }
205 :
206 296 : pub fn ancestor_lsn(&self) -> Lsn {
207 296 : self.body.ancestor_lsn
208 296 : }
209 :
210 296 : pub fn latest_gc_cutoff_lsn(&self) -> Lsn {
211 296 : self.body.latest_gc_cutoff_lsn
212 296 : }
213 :
214 296 : pub fn initdb_lsn(&self) -> Lsn {
215 296 : self.body.initdb_lsn
216 296 : }
217 :
218 296 : pub fn pg_version(&self) -> u32 {
219 296 : self.body.pg_version
220 296 : }
221 :
222 : // Checksums make it awkward to build a valid instance by hand. This helper
223 : // provides a TimelineMetadata with a valid checksum in its header.
224 : #[cfg(test)]
225 12 : pub fn example() -> Self {
226 12 : let instance = Self::new(
227 12 : "0/16960E8".parse::<Lsn>().unwrap(),
228 12 : None,
229 12 : None,
230 12 : Lsn::from_hex("00000000").unwrap(),
231 12 : Lsn::from_hex("00000000").unwrap(),
232 12 : Lsn::from_hex("00000000").unwrap(),
233 12 : 0,
234 12 : );
235 12 : let bytes = instance.to_bytes().unwrap();
236 12 : Self::from_bytes(&bytes).unwrap()
237 12 : }
238 : }
239 :
240 : impl<'de> Deserialize<'de> for TimelineMetadata {
241 34 : fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
242 34 : where
243 34 : D: serde::Deserializer<'de>,
244 34 : {
245 34 : let bytes = Vec::<u8>::deserialize(deserializer)?;
246 34 : Self::from_bytes(bytes.as_slice()).map_err(|e| D::Error::custom(format!("{e}")))
247 34 : }
248 : }
249 :
250 : impl Serialize for TimelineMetadata {
251 767 : fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
252 767 : where
253 767 : S: Serializer,
254 767 : {
255 767 : let bytes = self
256 767 : .to_bytes()
257 767 : .map_err(|e| serde::ser::Error::custom(format!("{e}")))?;
258 767 : bytes.serialize(serializer)
259 767 : }
260 : }
261 :
262 : #[cfg(test)]
263 : mod tests {
264 : use super::*;
265 : use crate::tenant::harness::TIMELINE_ID;
266 :
267 2 : #[test]
268 2 : fn metadata_serializes_correctly() {
269 2 : let original_metadata = TimelineMetadata::new(
270 2 : Lsn(0x200),
271 2 : Some(Lsn(0x100)),
272 2 : Some(TIMELINE_ID),
273 2 : Lsn(0),
274 2 : Lsn(0),
275 2 : Lsn(0),
276 2 : // Any version will do here, so use the default
277 2 : crate::DEFAULT_PG_VERSION,
278 2 : );
279 2 :
280 2 : let metadata_bytes = original_metadata
281 2 : .to_bytes()
282 2 : .expect("Should serialize correct metadata to bytes");
283 2 :
284 2 : let deserialized_metadata = TimelineMetadata::from_bytes(&metadata_bytes)
285 2 : .expect("Should deserialize its own bytes");
286 2 :
287 2 : assert_eq!(
288 : deserialized_metadata.body, original_metadata.body,
289 0 : "Metadata that was serialized to bytes and deserialized back should not change"
290 : );
291 2 : }
292 :
293 : // Generate old version metadata and read it with current code.
294 : // Ensure that it is upgraded correctly
295 2 : #[test]
296 2 : fn test_metadata_upgrade() {
297 2 : #[derive(Debug, Clone, PartialEq, Eq)]
298 2 : struct TimelineMetadataV1 {
299 2 : hdr: TimelineMetadataHeader,
300 2 : body: TimelineMetadataBodyV1,
301 2 : }
302 2 :
303 2 : let metadata_v1 = TimelineMetadataV1 {
304 2 : hdr: TimelineMetadataHeader {
305 2 : checksum: 0,
306 2 : size: 0,
307 2 : format_version: METADATA_OLD_FORMAT_VERSION,
308 2 : },
309 2 : body: TimelineMetadataBodyV1 {
310 2 : disk_consistent_lsn: Lsn(0x200),
311 2 : prev_record_lsn: Some(Lsn(0x100)),
312 2 : ancestor_timeline: Some(TIMELINE_ID),
313 2 : ancestor_lsn: Lsn(0),
314 2 : latest_gc_cutoff_lsn: Lsn(0),
315 2 : initdb_lsn: Lsn(0),
316 2 : },
317 2 : };
318 2 :
319 2 : impl TimelineMetadataV1 {
320 2 : pub fn to_bytes(&self) -> anyhow::Result<Vec<u8>> {
321 2 : let body_bytes = self.body.ser()?;
322 2 : let metadata_size = METADATA_HDR_SIZE + body_bytes.len();
323 2 : let hdr = TimelineMetadataHeader {
324 2 : size: metadata_size as u16,
325 2 : format_version: METADATA_OLD_FORMAT_VERSION,
326 2 : checksum: crc32c::crc32c(&body_bytes),
327 2 : };
328 2 : let hdr_bytes = hdr.ser()?;
329 2 : let mut metadata_bytes = vec![0u8; METADATA_MAX_SIZE];
330 2 : metadata_bytes[0..METADATA_HDR_SIZE].copy_from_slice(&hdr_bytes);
331 2 : metadata_bytes[METADATA_HDR_SIZE..metadata_size].copy_from_slice(&body_bytes);
332 2 : Ok(metadata_bytes)
333 2 : }
334 2 : }
335 2 :
336 2 : let metadata_bytes = metadata_v1
337 2 : .to_bytes()
338 2 : .expect("Should serialize correct metadata to bytes");
339 2 :
340 2 : // This should deserialize to the latest version format
341 2 : let deserialized_metadata = TimelineMetadata::from_bytes(&metadata_bytes)
342 2 : .expect("Should deserialize its own bytes");
343 2 :
344 2 : let expected_metadata = TimelineMetadata::new(
345 2 : Lsn(0x200),
346 2 : Some(Lsn(0x100)),
347 2 : Some(TIMELINE_ID),
348 2 : Lsn(0),
349 2 : Lsn(0),
350 2 : Lsn(0),
351 2 : 14, // All timelines created before this version had pg_version 14
352 2 : );
353 2 :
354 2 : assert_eq!(
355 : deserialized_metadata.body, expected_metadata.body,
356 0 : "Metadata of the old version {} should be upgraded to the latest version {}",
357 : METADATA_OLD_FORMAT_VERSION, METADATA_FORMAT_VERSION
358 : );
359 2 : }
360 :
361 2 : #[test]
362 2 : fn test_metadata_bincode_serde() {
363 2 : let original_metadata = TimelineMetadata::new(
364 2 : Lsn(0x200),
365 2 : Some(Lsn(0x100)),
366 2 : Some(TIMELINE_ID),
367 2 : Lsn(0),
368 2 : Lsn(0),
369 2 : Lsn(0),
370 2 : // Any version will do here, so use the default
371 2 : crate::DEFAULT_PG_VERSION,
372 2 : );
373 2 : let metadata_bytes = original_metadata
374 2 : .to_bytes()
375 2 : .expect("Cannot create bytes array from metadata");
376 2 :
377 2 : let metadata_bincode_be_bytes = original_metadata
378 2 : .ser()
379 2 : .expect("Cannot serialize the metadata");
380 2 :
381 2 : // 8 bytes for the length of the vector
382 2 : assert_eq!(metadata_bincode_be_bytes.len(), 8 + metadata_bytes.len());
383 :
384 2 : let expected_bincode_bytes = {
385 2 : let mut temp = vec![];
386 2 : let len_bytes = metadata_bytes.len().to_be_bytes();
387 2 : temp.extend_from_slice(&len_bytes);
388 2 : temp.extend_from_slice(&metadata_bytes);
389 2 : temp
390 2 : };
391 2 : assert_eq!(metadata_bincode_be_bytes, expected_bincode_bytes);
392 :
393 2 : let deserialized_metadata = TimelineMetadata::des(&metadata_bincode_be_bytes).unwrap();
394 2 : // Deserialized metadata has the metadata header, which is different from the serialized one.
395 2 : // Reference: TimelineMetaData::to_bytes()
396 2 : let expected_metadata = {
397 2 : let mut temp_metadata = original_metadata;
398 2 : let body_bytes = temp_metadata
399 2 : .body
400 2 : .ser()
401 2 : .expect("Cannot serialize the metadata body");
402 2 : let metadata_size = METADATA_HDR_SIZE + body_bytes.len();
403 2 : let hdr = TimelineMetadataHeader {
404 2 : size: metadata_size as u16,
405 2 : format_version: METADATA_FORMAT_VERSION,
406 2 : checksum: crc32c::crc32c(&body_bytes),
407 2 : };
408 2 : temp_metadata.hdr = hdr;
409 2 : temp_metadata
410 2 : };
411 2 : assert_eq!(deserialized_metadata, expected_metadata);
412 2 : }
413 :
414 2 : #[test]
415 2 : fn test_metadata_bincode_serde_ensure_roundtrip() {
416 2 : let original_metadata = TimelineMetadata::new(
417 2 : Lsn(0x200),
418 2 : Some(Lsn(0x100)),
419 2 : Some(TIMELINE_ID),
420 2 : Lsn(0),
421 2 : Lsn(0),
422 2 : Lsn(0),
423 2 : // Any version will do here, so use the default
424 2 : crate::DEFAULT_PG_VERSION,
425 2 : );
426 2 : let expected_bytes = vec![
427 2 : /* bincode length encoding bytes */
428 2 : 0, 0, 0, 0, 0, 0, 2, 0, // 8 bytes for the length of the serialized vector
429 2 : /* TimelineMetadataHeader */
430 2 : 4, 37, 101, 34, 0, 70, 0, 4, // checksum, size, format_version (4 + 2 + 2)
431 2 : /* TimelineMetadataBodyV2 */
432 2 : 0, 0, 0, 0, 0, 0, 2, 0, // disk_consistent_lsn (8 bytes)
433 2 : 1, 0, 0, 0, 0, 0, 0, 1, 0, // prev_record_lsn (9 bytes)
434 2 : 1, 17, 34, 51, 68, 85, 102, 119, 136, 17, 34, 51, 68, 85, 102, 119,
435 2 : 136, // ancestor_timeline (17 bytes)
436 2 : 0, 0, 0, 0, 0, 0, 0, 0, // ancestor_lsn (8 bytes)
437 2 : 0, 0, 0, 0, 0, 0, 0, 0, // latest_gc_cutoff_lsn (8 bytes)
438 2 : 0, 0, 0, 0, 0, 0, 0, 0, // initdb_lsn (8 bytes)
439 2 : 0, 0, 0, 15, // pg_version (4 bytes)
440 2 : /* padding bytes */
441 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
442 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
443 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
444 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
445 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
446 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
447 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
448 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
449 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
450 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
451 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
452 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
453 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
454 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
455 2 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
456 2 : 0, 0, 0, 0, 0, 0, 0,
457 2 : ];
458 2 : let metadata_ser_bytes = original_metadata.ser().unwrap();
459 2 : assert_eq!(metadata_ser_bytes, expected_bytes);
460 :
461 2 : let expected_metadata = {
462 2 : let mut temp_metadata = original_metadata;
463 2 : let body_bytes = temp_metadata
464 2 : .body
465 2 : .ser()
466 2 : .expect("Cannot serialize the metadata body");
467 2 : let metadata_size = METADATA_HDR_SIZE + body_bytes.len();
468 2 : let hdr = TimelineMetadataHeader {
469 2 : size: metadata_size as u16,
470 2 : format_version: METADATA_FORMAT_VERSION,
471 2 : checksum: crc32c::crc32c(&body_bytes),
472 2 : };
473 2 : temp_metadata.hdr = hdr;
474 2 : temp_metadata
475 2 : };
476 2 : let des_metadata = TimelineMetadata::des(&metadata_ser_bytes).unwrap();
477 2 : assert_eq!(des_metadata, expected_metadata);
478 2 : }
479 : }
|
