Line data Source code
1 : //! Code to deal with safekeeper control file upgrades
2 : use crate::{
3 : safekeeper::{AcceptorState, PgUuid, TermHistory, TermLsn},
4 : state::{EvictionState, PersistedPeers, TimelinePersistentState},
5 : wal_backup_partial,
6 : };
7 : use anyhow::{bail, Result};
8 : use pq_proto::SystemId;
9 : use safekeeper_api::{ServerInfo, Term};
10 : use serde::{Deserialize, Serialize};
11 : use tracing::*;
12 : use utils::{
13 : bin_ser::LeSer,
14 : id::{TenantId, TimelineId},
15 : lsn::Lsn,
16 : };
17 :
18 : /// Persistent consensus state of the acceptor.
19 1 : #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
20 : struct AcceptorStateV1 {
21 : /// acceptor's last term it voted for (advanced in 1 phase)
22 : term: Term,
23 : /// acceptor's epoch (advanced, i.e. bumped to 'term' when VCL is reached).
24 : epoch: Term,
25 : }
26 :
27 1 : #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
28 : struct SafeKeeperStateV1 {
29 : /// persistent acceptor state
30 : acceptor_state: AcceptorStateV1,
31 : /// information about server
32 : server: ServerInfoV2,
33 : /// Unique id of the last *elected* proposer we dealt with. Not needed
34 : /// for correctness, exists for monitoring purposes.
35 : proposer_uuid: PgUuid,
36 : /// part of WAL acknowledged by quorum and available locally
37 : commit_lsn: Lsn,
38 : /// minimal LSN which may be needed for recovery of some safekeeper (end_lsn
39 : /// of last record streamed to everyone)
40 : truncate_lsn: Lsn,
41 : // Safekeeper starts receiving WAL from this LSN, zeros before it ought to
42 : // be skipped during decoding.
43 : wal_start_lsn: Lsn,
44 : }
45 :
46 2 : #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
47 : pub struct ServerInfoV2 {
48 : /// Postgres server version
49 : pub pg_version: u32,
50 : pub system_id: SystemId,
51 : pub tenant_id: TenantId,
52 : pub timeline_id: TimelineId,
53 : pub wal_seg_size: u32,
54 : }
55 :
56 1 : #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
57 : pub struct SafeKeeperStateV2 {
58 : /// persistent acceptor state
59 : pub acceptor_state: AcceptorState,
60 : /// information about server
61 : pub server: ServerInfoV2,
62 : /// Unique id of the last *elected* proposer we dealt with. Not needed
63 : /// for correctness, exists for monitoring purposes.
64 : pub proposer_uuid: PgUuid,
65 : /// part of WAL acknowledged by quorum and available locally
66 : pub commit_lsn: Lsn,
67 : /// minimal LSN which may be needed for recovery of some safekeeper (end_lsn
68 : /// of last record streamed to everyone)
69 : pub truncate_lsn: Lsn,
70 : // Safekeeper starts receiving WAL from this LSN, zeros before it ought to
71 : // be skipped during decoding.
72 : pub wal_start_lsn: Lsn,
73 : }
74 :
75 4 : #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
76 : pub struct ServerInfoV3 {
77 : /// Postgres server version
78 : pub pg_version: u32,
79 : pub system_id: SystemId,
80 : #[serde(with = "hex")]
81 : pub tenant_id: TenantId,
82 : #[serde(with = "hex")]
83 : pub timeline_id: TimelineId,
84 : pub wal_seg_size: u32,
85 : }
86 :
87 2 : #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
88 : pub struct SafeKeeperStateV3 {
89 : /// persistent acceptor state
90 : pub acceptor_state: AcceptorState,
91 : /// information about server
92 : pub server: ServerInfoV3,
93 : /// Unique id of the last *elected* proposer we dealt with. Not needed
94 : /// for correctness, exists for monitoring purposes.
95 : #[serde(with = "hex")]
96 : pub proposer_uuid: PgUuid,
97 : /// part of WAL acknowledged by quorum and available locally
98 : pub commit_lsn: Lsn,
99 : /// minimal LSN which may be needed for recovery of some safekeeper (end_lsn
100 : /// of last record streamed to everyone)
101 : pub truncate_lsn: Lsn,
102 : // Safekeeper starts receiving WAL from this LSN, zeros before it ought to
103 : // be skipped during decoding.
104 : pub wal_start_lsn: Lsn,
105 : }
106 :
107 6 : #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
108 : pub struct SafeKeeperStateV4 {
109 : #[serde(with = "hex")]
110 : pub tenant_id: TenantId,
111 : #[serde(with = "hex")]
112 : pub timeline_id: TimelineId,
113 : /// persistent acceptor state
114 : pub acceptor_state: AcceptorState,
115 : /// information about server
116 : pub server: ServerInfo,
117 : /// Unique id of the last *elected* proposer we dealt with. Not needed
118 : /// for correctness, exists for monitoring purposes.
119 : #[serde(with = "hex")]
120 : pub proposer_uuid: PgUuid,
121 : /// Part of WAL acknowledged by quorum and available locally. Always points
122 : /// to record boundary.
123 : pub commit_lsn: Lsn,
124 : /// First LSN not yet offloaded to s3. Useful to persist to avoid finding
125 : /// out offloading progress on boot.
126 : pub s3_wal_lsn: Lsn,
127 : /// Minimal LSN which may be needed for recovery of some safekeeper (end_lsn
128 : /// of last record streamed to everyone). Persisting it helps skipping
129 : /// recovery in walproposer, generally we compute it from peers. In
130 : /// walproposer proto called 'truncate_lsn'.
131 : pub peer_horizon_lsn: Lsn,
132 : /// LSN of the oldest known checkpoint made by pageserver and successfully
133 : /// pushed to s3. We don't remove WAL beyond it. Persisted only for
134 : /// informational purposes, we receive it from pageserver (or broker).
135 : pub remote_consistent_lsn: Lsn,
136 : // Peers and their state as we remember it. Knowing peers themselves is
137 : // fundamental; but state is saved here only for informational purposes and
138 : // obviously can be stale. (Currently not saved at all, but let's provision
139 : // place to have less file version upgrades).
140 : pub peers: PersistedPeers,
141 : }
142 :
143 0 : #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
144 : pub struct SafeKeeperStateV7 {
145 : #[serde(with = "hex")]
146 : pub tenant_id: TenantId,
147 : #[serde(with = "hex")]
148 : pub timeline_id: TimelineId,
149 : /// persistent acceptor state
150 : pub acceptor_state: AcceptorState,
151 : /// information about server
152 : pub server: ServerInfo,
153 : /// Unique id of the last *elected* proposer we dealt with. Not needed
154 : /// for correctness, exists for monitoring purposes.
155 : #[serde(with = "hex")]
156 : pub proposer_uuid: PgUuid,
157 : /// Since which LSN this timeline generally starts. Safekeeper might have
158 : /// joined later.
159 : pub timeline_start_lsn: Lsn,
160 : /// Since which LSN safekeeper has (had) WAL for this timeline.
161 : /// All WAL segments next to one containing local_start_lsn are
162 : /// filled with data from the beginning.
163 : pub local_start_lsn: Lsn,
164 : /// Part of WAL acknowledged by quorum *and available locally*. Always points
165 : /// to record boundary.
166 : pub commit_lsn: Lsn,
167 : /// LSN that points to the end of the last backed up segment. Useful to
168 : /// persist to avoid finding out offloading progress on boot.
169 : pub backup_lsn: Lsn,
170 : /// Minimal LSN which may be needed for recovery of some safekeeper (end_lsn
171 : /// of last record streamed to everyone). Persisting it helps skipping
172 : /// recovery in walproposer, generally we compute it from peers. In
173 : /// walproposer proto called 'truncate_lsn'. Updates are currently drived
174 : /// only by walproposer.
175 : pub peer_horizon_lsn: Lsn,
176 : /// LSN of the oldest known checkpoint made by pageserver and successfully
177 : /// pushed to s3. We don't remove WAL beyond it. Persisted only for
178 : /// informational purposes, we receive it from pageserver (or broker).
179 : pub remote_consistent_lsn: Lsn,
180 : // Peers and their state as we remember it. Knowing peers themselves is
181 : // fundamental; but state is saved here only for informational purposes and
182 : // obviously can be stale. (Currently not saved at all, but let's provision
183 : // place to have less file version upgrades).
184 : pub peers: PersistedPeers,
185 : }
186 :
187 : /// Persistent information stored on safekeeper node about timeline.
188 : /// On disk data is prefixed by magic and format version and followed by checksum.
189 12 : #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
190 : pub struct SafeKeeperStateV8 {
191 : #[serde(with = "hex")]
192 : pub tenant_id: TenantId,
193 : #[serde(with = "hex")]
194 : pub timeline_id: TimelineId,
195 : /// persistent acceptor state
196 : pub acceptor_state: AcceptorState,
197 : /// information about server
198 : pub server: ServerInfo,
199 : /// Unique id of the last *elected* proposer we dealt with. Not needed
200 : /// for correctness, exists for monitoring purposes.
201 : #[serde(with = "hex")]
202 : pub proposer_uuid: PgUuid,
203 : /// Since which LSN this timeline generally starts. Safekeeper might have
204 : /// joined later.
205 : pub timeline_start_lsn: Lsn,
206 : /// Since which LSN safekeeper has (had) WAL for this timeline.
207 : /// All WAL segments next to one containing local_start_lsn are
208 : /// filled with data from the beginning.
209 : pub local_start_lsn: Lsn,
210 : /// Part of WAL acknowledged by quorum *and available locally*. Always points
211 : /// to record boundary.
212 : pub commit_lsn: Lsn,
213 : /// LSN that points to the end of the last backed up segment. Useful to
214 : /// persist to avoid finding out offloading progress on boot.
215 : pub backup_lsn: Lsn,
216 : /// Minimal LSN which may be needed for recovery of some safekeeper (end_lsn
217 : /// of last record streamed to everyone). Persisting it helps skipping
218 : /// recovery in walproposer, generally we compute it from peers. In
219 : /// walproposer proto called 'truncate_lsn'. Updates are currently drived
220 : /// only by walproposer.
221 : pub peer_horizon_lsn: Lsn,
222 : /// LSN of the oldest known checkpoint made by pageserver and successfully
223 : /// pushed to s3. We don't remove WAL beyond it. Persisted only for
224 : /// informational purposes, we receive it from pageserver (or broker).
225 : pub remote_consistent_lsn: Lsn,
226 : /// Peers and their state as we remember it. Knowing peers themselves is
227 : /// fundamental; but state is saved here only for informational purposes and
228 : /// obviously can be stale. (Currently not saved at all, but let's provision
229 : /// place to have less file version upgrades).
230 : pub peers: PersistedPeers,
231 : /// Holds names of partial segments uploaded to remote storage. Used to
232 : /// clean up old objects without leaving garbage in remote storage.
233 : pub partial_backup: wal_backup_partial::State,
234 : }
235 :
236 1 : pub fn upgrade_control_file(buf: &[u8], version: u32) -> Result<TimelinePersistentState> {
237 1 : // migrate to storing full term history
238 1 : if version == 1 {
239 0 : info!("reading safekeeper control file version {}", version);
240 0 : let oldstate = SafeKeeperStateV1::des(&buf[..buf.len()])?;
241 0 : let ac = AcceptorState {
242 0 : term: oldstate.acceptor_state.term,
243 0 : term_history: TermHistory(vec![TermLsn {
244 0 : term: oldstate.acceptor_state.epoch,
245 0 : lsn: Lsn(0),
246 0 : }]),
247 0 : };
248 0 : return Ok(TimelinePersistentState {
249 0 : tenant_id: oldstate.server.tenant_id,
250 0 : timeline_id: oldstate.server.timeline_id,
251 0 : acceptor_state: ac,
252 0 : server: ServerInfo {
253 0 : pg_version: oldstate.server.pg_version,
254 0 : system_id: oldstate.server.system_id,
255 0 : wal_seg_size: oldstate.server.wal_seg_size,
256 0 : },
257 0 : proposer_uuid: oldstate.proposer_uuid,
258 0 : timeline_start_lsn: Lsn(0),
259 0 : local_start_lsn: Lsn(0),
260 0 : commit_lsn: oldstate.commit_lsn,
261 0 : backup_lsn: Lsn(0),
262 0 : peer_horizon_lsn: oldstate.truncate_lsn,
263 0 : remote_consistent_lsn: Lsn(0),
264 0 : peers: PersistedPeers(vec![]),
265 0 : partial_backup: wal_backup_partial::State::default(),
266 0 : eviction_state: EvictionState::Present,
267 0 : });
268 : // migrate to hexing some ids
269 1 : } else if version == 2 {
270 0 : info!("reading safekeeper control file version {}", version);
271 0 : let oldstate = SafeKeeperStateV2::des(&buf[..buf.len()])?;
272 0 : let server = ServerInfo {
273 0 : pg_version: oldstate.server.pg_version,
274 0 : system_id: oldstate.server.system_id,
275 0 : wal_seg_size: oldstate.server.wal_seg_size,
276 0 : };
277 0 : return Ok(TimelinePersistentState {
278 0 : tenant_id: oldstate.server.tenant_id,
279 0 : timeline_id: oldstate.server.timeline_id,
280 0 : acceptor_state: oldstate.acceptor_state,
281 0 : server,
282 0 : proposer_uuid: oldstate.proposer_uuid,
283 0 : timeline_start_lsn: Lsn(0),
284 0 : local_start_lsn: Lsn(0),
285 0 : commit_lsn: oldstate.commit_lsn,
286 0 : backup_lsn: Lsn(0),
287 0 : peer_horizon_lsn: oldstate.truncate_lsn,
288 0 : remote_consistent_lsn: Lsn(0),
289 0 : peers: PersistedPeers(vec![]),
290 0 : partial_backup: wal_backup_partial::State::default(),
291 0 : eviction_state: EvictionState::Present,
292 0 : });
293 : // migrate to moving tenant_id/timeline_id to the top and adding some lsns
294 1 : } else if version == 3 {
295 0 : info!("reading safekeeper control file version {version}");
296 0 : let oldstate = SafeKeeperStateV3::des(&buf[..buf.len()])?;
297 0 : let server = ServerInfo {
298 0 : pg_version: oldstate.server.pg_version,
299 0 : system_id: oldstate.server.system_id,
300 0 : wal_seg_size: oldstate.server.wal_seg_size,
301 0 : };
302 0 : return Ok(TimelinePersistentState {
303 0 : tenant_id: oldstate.server.tenant_id,
304 0 : timeline_id: oldstate.server.timeline_id,
305 0 : acceptor_state: oldstate.acceptor_state,
306 0 : server,
307 0 : proposer_uuid: oldstate.proposer_uuid,
308 0 : timeline_start_lsn: Lsn(0),
309 0 : local_start_lsn: Lsn(0),
310 0 : commit_lsn: oldstate.commit_lsn,
311 0 : backup_lsn: Lsn(0),
312 0 : peer_horizon_lsn: oldstate.truncate_lsn,
313 0 : remote_consistent_lsn: Lsn(0),
314 0 : peers: PersistedPeers(vec![]),
315 0 : partial_backup: wal_backup_partial::State::default(),
316 0 : eviction_state: EvictionState::Present,
317 0 : });
318 : // migrate to having timeline_start_lsn
319 1 : } else if version == 4 {
320 0 : info!("reading safekeeper control file version {}", version);
321 0 : let oldstate = SafeKeeperStateV4::des(&buf[..buf.len()])?;
322 0 : let server = ServerInfo {
323 0 : pg_version: oldstate.server.pg_version,
324 0 : system_id: oldstate.server.system_id,
325 0 : wal_seg_size: oldstate.server.wal_seg_size,
326 0 : };
327 0 : return Ok(TimelinePersistentState {
328 0 : tenant_id: oldstate.tenant_id,
329 0 : timeline_id: oldstate.timeline_id,
330 0 : acceptor_state: oldstate.acceptor_state,
331 0 : server,
332 0 : proposer_uuid: oldstate.proposer_uuid,
333 0 : timeline_start_lsn: Lsn(0),
334 0 : local_start_lsn: Lsn(0),
335 0 : commit_lsn: oldstate.commit_lsn,
336 0 : backup_lsn: Lsn::INVALID,
337 0 : peer_horizon_lsn: oldstate.peer_horizon_lsn,
338 0 : remote_consistent_lsn: Lsn(0),
339 0 : peers: PersistedPeers(vec![]),
340 0 : partial_backup: wal_backup_partial::State::default(),
341 0 : eviction_state: EvictionState::Present,
342 0 : });
343 1 : } else if version == 5 {
344 0 : info!("reading safekeeper control file version {}", version);
345 0 : let mut oldstate = TimelinePersistentState::des(&buf[..buf.len()])?;
346 0 : if oldstate.timeline_start_lsn != Lsn(0) {
347 0 : return Ok(oldstate);
348 0 : }
349 0 :
350 0 : // set special timeline_start_lsn because we don't know the real one
351 0 : info!("setting timeline_start_lsn and local_start_lsn to Lsn(1)");
352 0 : oldstate.timeline_start_lsn = Lsn(1);
353 0 : oldstate.local_start_lsn = Lsn(1);
354 0 :
355 0 : return Ok(oldstate);
356 1 : } else if version == 6 {
357 0 : info!("reading safekeeper control file version {}", version);
358 0 : let mut oldstate = TimelinePersistentState::des(&buf[..buf.len()])?;
359 0 : if oldstate.server.pg_version != 0 {
360 0 : return Ok(oldstate);
361 0 : }
362 0 :
363 0 : // set pg_version to the default v14
364 0 : info!("setting pg_version to 140005");
365 0 : oldstate.server.pg_version = 140005;
366 0 :
367 0 : return Ok(oldstate);
368 1 : } else if version == 7 {
369 0 : info!("reading safekeeper control file version {}", version);
370 0 : let oldstate = SafeKeeperStateV7::des(&buf[..buf.len()])?;
371 :
372 0 : return Ok(TimelinePersistentState {
373 0 : tenant_id: oldstate.tenant_id,
374 0 : timeline_id: oldstate.timeline_id,
375 0 : acceptor_state: oldstate.acceptor_state,
376 0 : server: oldstate.server,
377 0 : proposer_uuid: oldstate.proposer_uuid,
378 0 : timeline_start_lsn: oldstate.timeline_start_lsn,
379 0 : local_start_lsn: oldstate.local_start_lsn,
380 0 : commit_lsn: oldstate.commit_lsn,
381 0 : backup_lsn: oldstate.backup_lsn,
382 0 : peer_horizon_lsn: oldstate.peer_horizon_lsn,
383 0 : remote_consistent_lsn: oldstate.remote_consistent_lsn,
384 0 : peers: oldstate.peers,
385 0 : partial_backup: wal_backup_partial::State::default(),
386 0 : eviction_state: EvictionState::Present,
387 0 : });
388 1 : } else if version == 8 {
389 1 : let oldstate = SafeKeeperStateV8::des(&buf[..buf.len()])?;
390 :
391 1 : return Ok(TimelinePersistentState {
392 1 : tenant_id: oldstate.tenant_id,
393 1 : timeline_id: oldstate.timeline_id,
394 1 : acceptor_state: oldstate.acceptor_state,
395 1 : server: oldstate.server,
396 1 : proposer_uuid: oldstate.proposer_uuid,
397 1 : timeline_start_lsn: oldstate.timeline_start_lsn,
398 1 : local_start_lsn: oldstate.local_start_lsn,
399 1 : commit_lsn: oldstate.commit_lsn,
400 1 : backup_lsn: oldstate.backup_lsn,
401 1 : peer_horizon_lsn: oldstate.peer_horizon_lsn,
402 1 : remote_consistent_lsn: oldstate.remote_consistent_lsn,
403 1 : peers: oldstate.peers,
404 1 : partial_backup: oldstate.partial_backup,
405 1 : eviction_state: EvictionState::Present,
406 1 : });
407 0 : }
408 0 :
409 0 : // TODO: persist the file back to the disk after upgrade
410 0 : // TODO: think about backward compatibility and rollbacks
411 0 :
412 0 : bail!("unsupported safekeeper control file version {}", version)
413 1 : }
414 :
415 4 : pub fn downgrade_v9_to_v8(state: &TimelinePersistentState) -> SafeKeeperStateV8 {
416 4 : assert!(state.eviction_state == EvictionState::Present);
417 4 : SafeKeeperStateV8 {
418 4 : tenant_id: state.tenant_id,
419 4 : timeline_id: state.timeline_id,
420 4 : acceptor_state: state.acceptor_state.clone(),
421 4 : server: state.server.clone(),
422 4 : proposer_uuid: state.proposer_uuid,
423 4 : timeline_start_lsn: state.timeline_start_lsn,
424 4 : local_start_lsn: state.local_start_lsn,
425 4 : commit_lsn: state.commit_lsn,
426 4 : backup_lsn: state.backup_lsn,
427 4 : peer_horizon_lsn: state.peer_horizon_lsn,
428 4 : remote_consistent_lsn: state.remote_consistent_lsn,
429 4 : peers: state.peers.clone(),
430 4 : partial_backup: state.partial_backup.clone(),
431 4 : }
432 4 : }
433 :
434 : #[cfg(test)]
435 : mod tests {
436 : use std::str::FromStr;
437 :
438 : use utils::{id::NodeId, Hex};
439 :
440 : use crate::safekeeper::PersistedPeerInfo;
441 :
442 : use super::*;
443 :
444 : #[test]
445 1 : fn roundtrip_v1() {
446 1 : let tenant_id = TenantId::from_str("cf0480929707ee75372337efaa5ecf96").unwrap();
447 1 : let timeline_id = TimelineId::from_str("112ded66422aa5e953e5440fa5427ac4").unwrap();
448 1 : let state = SafeKeeperStateV1 {
449 1 : acceptor_state: AcceptorStateV1 {
450 1 : term: 42,
451 1 : epoch: 43,
452 1 : },
453 1 : server: ServerInfoV2 {
454 1 : pg_version: 14,
455 1 : system_id: 0x1234567887654321,
456 1 : tenant_id,
457 1 : timeline_id,
458 1 : wal_seg_size: 0x12345678,
459 1 : },
460 1 : proposer_uuid: {
461 1 : let mut arr = timeline_id.as_arr();
462 1 : arr.reverse();
463 1 : arr
464 1 : },
465 1 : commit_lsn: Lsn(1234567800),
466 1 : truncate_lsn: Lsn(123456780),
467 1 : wal_start_lsn: Lsn(1234567800 - 8),
468 1 : };
469 1 :
470 1 : let ser = state.ser().unwrap();
471 1 : #[rustfmt::skip]
472 1 : let expected = [
473 1 : // term
474 1 : 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
475 1 : // epoch
476 1 : 0x2b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
477 1 : // pg_version
478 1 : 0x0e, 0x00, 0x00, 0x00,
479 1 : // system_id
480 1 : 0x21, 0x43, 0x65, 0x87, 0x78, 0x56, 0x34, 0x12,
481 1 : // tenant_id
482 1 : 0xcf, 0x04, 0x80, 0x92, 0x97, 0x07, 0xee, 0x75, 0x37, 0x23, 0x37, 0xef, 0xaa, 0x5e, 0xcf, 0x96,
483 1 : // timeline_id
484 1 : 0x11, 0x2d, 0xed, 0x66, 0x42, 0x2a, 0xa5, 0xe9, 0x53, 0xe5, 0x44, 0x0f, 0xa5, 0x42, 0x7a, 0xc4,
485 1 : // wal_seg_size
486 1 : 0x78, 0x56, 0x34, 0x12,
487 1 : // proposer_uuid
488 1 : 0xc4, 0x7a, 0x42, 0xa5, 0x0f, 0x44, 0xe5, 0x53, 0xe9, 0xa5, 0x2a, 0x42, 0x66, 0xed, 0x2d, 0x11,
489 1 : // commit_lsn
490 1 : 0x78, 0x02, 0x96, 0x49, 0x00, 0x00, 0x00, 0x00,
491 1 : // truncate_lsn
492 1 : 0x0c, 0xcd, 0x5b, 0x07, 0x00, 0x00, 0x00, 0x00,
493 1 : // wal_start_lsn
494 1 : 0x70, 0x02, 0x96, 0x49, 0x00, 0x00, 0x00, 0x00,
495 1 : ];
496 1 :
497 1 : assert_eq!(Hex(&ser), Hex(&expected));
498 :
499 1 : let deser = SafeKeeperStateV1::des(&ser).unwrap();
500 1 :
501 1 : assert_eq!(state, deser);
502 1 : }
503 :
504 : #[test]
505 1 : fn roundtrip_v2() {
506 1 : let tenant_id = TenantId::from_str("cf0480929707ee75372337efaa5ecf96").unwrap();
507 1 : let timeline_id = TimelineId::from_str("112ded66422aa5e953e5440fa5427ac4").unwrap();
508 1 : let state = SafeKeeperStateV2 {
509 1 : acceptor_state: AcceptorState {
510 1 : term: 42,
511 1 : term_history: TermHistory(vec![TermLsn {
512 1 : lsn: Lsn(0x1),
513 1 : term: 41,
514 1 : }]),
515 1 : },
516 1 : server: ServerInfoV2 {
517 1 : pg_version: 14,
518 1 : system_id: 0x1234567887654321,
519 1 : tenant_id,
520 1 : timeline_id,
521 1 : wal_seg_size: 0x12345678,
522 1 : },
523 1 : proposer_uuid: {
524 1 : let mut arr = timeline_id.as_arr();
525 1 : arr.reverse();
526 1 : arr
527 1 : },
528 1 : commit_lsn: Lsn(1234567800),
529 1 : truncate_lsn: Lsn(123456780),
530 1 : wal_start_lsn: Lsn(1234567800 - 8),
531 1 : };
532 1 :
533 1 : let ser = state.ser().unwrap();
534 1 : let expected = [
535 1 : 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
536 1 : 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
537 1 : 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x21, 0x43, 0x65, 0x87, 0x78, 0x56,
538 1 : 0x34, 0x12, 0xcf, 0x04, 0x80, 0x92, 0x97, 0x07, 0xee, 0x75, 0x37, 0x23, 0x37, 0xef,
539 1 : 0xaa, 0x5e, 0xcf, 0x96, 0x11, 0x2d, 0xed, 0x66, 0x42, 0x2a, 0xa5, 0xe9, 0x53, 0xe5,
540 1 : 0x44, 0x0f, 0xa5, 0x42, 0x7a, 0xc4, 0x78, 0x56, 0x34, 0x12, 0xc4, 0x7a, 0x42, 0xa5,
541 1 : 0x0f, 0x44, 0xe5, 0x53, 0xe9, 0xa5, 0x2a, 0x42, 0x66, 0xed, 0x2d, 0x11, 0x78, 0x02,
542 1 : 0x96, 0x49, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xcd, 0x5b, 0x07, 0x00, 0x00, 0x00, 0x00,
543 1 : 0x70, 0x02, 0x96, 0x49, 0x00, 0x00, 0x00, 0x00,
544 1 : ];
545 1 :
546 1 : assert_eq!(Hex(&ser), Hex(&expected));
547 :
548 1 : let deser = SafeKeeperStateV2::des(&ser).unwrap();
549 1 :
550 1 : assert_eq!(state, deser);
551 1 : }
552 :
553 : #[test]
554 1 : fn roundtrip_v3() {
555 1 : let tenant_id = TenantId::from_str("cf0480929707ee75372337efaa5ecf96").unwrap();
556 1 : let timeline_id = TimelineId::from_str("112ded66422aa5e953e5440fa5427ac4").unwrap();
557 1 : let state = SafeKeeperStateV3 {
558 1 : acceptor_state: AcceptorState {
559 1 : term: 42,
560 1 : term_history: TermHistory(vec![TermLsn {
561 1 : lsn: Lsn(0x1),
562 1 : term: 41,
563 1 : }]),
564 1 : },
565 1 : server: ServerInfoV3 {
566 1 : pg_version: 14,
567 1 : system_id: 0x1234567887654321,
568 1 : tenant_id,
569 1 : timeline_id,
570 1 : wal_seg_size: 0x12345678,
571 1 : },
572 1 : proposer_uuid: {
573 1 : let mut arr = timeline_id.as_arr();
574 1 : arr.reverse();
575 1 : arr
576 1 : },
577 1 : commit_lsn: Lsn(1234567800),
578 1 : truncate_lsn: Lsn(123456780),
579 1 : wal_start_lsn: Lsn(1234567800 - 8),
580 1 : };
581 1 :
582 1 : let ser = state.ser().unwrap();
583 1 : let expected = [
584 1 : 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
585 1 : 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
586 1 : 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x21, 0x43, 0x65, 0x87, 0x78, 0x56,
587 1 : 0x34, 0x12, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x66, 0x30, 0x34,
588 1 : 0x38, 0x30, 0x39, 0x32, 0x39, 0x37, 0x30, 0x37, 0x65, 0x65, 0x37, 0x35, 0x33, 0x37,
589 1 : 0x32, 0x33, 0x33, 0x37, 0x65, 0x66, 0x61, 0x61, 0x35, 0x65, 0x63, 0x66, 0x39, 0x36,
590 1 : 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x31, 0x32, 0x64, 0x65, 0x64,
591 1 : 0x36, 0x36, 0x34, 0x32, 0x32, 0x61, 0x61, 0x35, 0x65, 0x39, 0x35, 0x33, 0x65, 0x35,
592 1 : 0x34, 0x34, 0x30, 0x66, 0x61, 0x35, 0x34, 0x32, 0x37, 0x61, 0x63, 0x34, 0x78, 0x56,
593 1 : 0x34, 0x12, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x34, 0x37, 0x61,
594 1 : 0x34, 0x32, 0x61, 0x35, 0x30, 0x66, 0x34, 0x34, 0x65, 0x35, 0x35, 0x33, 0x65, 0x39,
595 1 : 0x61, 0x35, 0x32, 0x61, 0x34, 0x32, 0x36, 0x36, 0x65, 0x64, 0x32, 0x64, 0x31, 0x31,
596 1 : 0x78, 0x02, 0x96, 0x49, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xcd, 0x5b, 0x07, 0x00, 0x00,
597 1 : 0x00, 0x00, 0x70, 0x02, 0x96, 0x49, 0x00, 0x00, 0x00, 0x00,
598 1 : ];
599 1 :
600 1 : assert_eq!(Hex(&ser), Hex(&expected));
601 :
602 1 : let deser = SafeKeeperStateV3::des(&ser).unwrap();
603 1 :
604 1 : assert_eq!(state, deser);
605 1 : }
606 :
607 : #[test]
608 1 : fn roundtrip_v4() {
609 1 : let tenant_id = TenantId::from_str("cf0480929707ee75372337efaa5ecf96").unwrap();
610 1 : let timeline_id = TimelineId::from_str("112ded66422aa5e953e5440fa5427ac4").unwrap();
611 1 : let state = SafeKeeperStateV4 {
612 1 : tenant_id,
613 1 : timeline_id,
614 1 : acceptor_state: AcceptorState {
615 1 : term: 42,
616 1 : term_history: TermHistory(vec![TermLsn {
617 1 : lsn: Lsn(0x1),
618 1 : term: 41,
619 1 : }]),
620 1 : },
621 1 : server: ServerInfo {
622 1 : pg_version: 14,
623 1 : system_id: 0x1234567887654321,
624 1 : wal_seg_size: 0x12345678,
625 1 : },
626 1 : proposer_uuid: {
627 1 : let mut arr = timeline_id.as_arr();
628 1 : arr.reverse();
629 1 : arr
630 1 : },
631 1 : peers: PersistedPeers(vec![(
632 1 : NodeId(1),
633 1 : PersistedPeerInfo {
634 1 : backup_lsn: Lsn(1234567000),
635 1 : term: 42,
636 1 : flush_lsn: Lsn(1234567800 - 8),
637 1 : commit_lsn: Lsn(1234567600),
638 1 : },
639 1 : )]),
640 1 : commit_lsn: Lsn(1234567800),
641 1 : s3_wal_lsn: Lsn(1234567300),
642 1 : peer_horizon_lsn: Lsn(9999999),
643 1 : remote_consistent_lsn: Lsn(1234560000),
644 1 : };
645 1 :
646 1 : let ser = state.ser().unwrap();
647 1 : let expected = [
648 1 : 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x66, 0x30, 0x34, 0x38, 0x30,
649 1 : 0x39, 0x32, 0x39, 0x37, 0x30, 0x37, 0x65, 0x65, 0x37, 0x35, 0x33, 0x37, 0x32, 0x33,
650 1 : 0x33, 0x37, 0x65, 0x66, 0x61, 0x61, 0x35, 0x65, 0x63, 0x66, 0x39, 0x36, 0x20, 0x00,
651 1 : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x31, 0x32, 0x64, 0x65, 0x64, 0x36, 0x36,
652 1 : 0x34, 0x32, 0x32, 0x61, 0x61, 0x35, 0x65, 0x39, 0x35, 0x33, 0x65, 0x35, 0x34, 0x34,
653 1 : 0x30, 0x66, 0x61, 0x35, 0x34, 0x32, 0x37, 0x61, 0x63, 0x34, 0x2a, 0x00, 0x00, 0x00,
654 1 : 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x00,
655 1 : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
656 1 : 0x0e, 0x00, 0x00, 0x00, 0x21, 0x43, 0x65, 0x87, 0x78, 0x56, 0x34, 0x12, 0x78, 0x56,
657 1 : 0x34, 0x12, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x34, 0x37, 0x61,
658 1 : 0x34, 0x32, 0x61, 0x35, 0x30, 0x66, 0x34, 0x34, 0x65, 0x35, 0x35, 0x33, 0x65, 0x39,
659 1 : 0x61, 0x35, 0x32, 0x61, 0x34, 0x32, 0x36, 0x36, 0x65, 0x64, 0x32, 0x64, 0x31, 0x31,
660 1 : 0x78, 0x02, 0x96, 0x49, 0x00, 0x00, 0x00, 0x00, 0x84, 0x00, 0x96, 0x49, 0x00, 0x00,
661 1 : 0x00, 0x00, 0x7f, 0x96, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe4, 0x95, 0x49,
662 1 : 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
663 1 : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0xff, 0x95, 0x49, 0x00, 0x00, 0x00, 0x00,
664 1 : 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x02, 0x96, 0x49, 0x00, 0x00,
665 1 : 0x00, 0x00, 0xb0, 0x01, 0x96, 0x49, 0x00, 0x00, 0x00, 0x00,
666 1 : ];
667 1 :
668 1 : assert_eq!(Hex(&ser), Hex(&expected));
669 :
670 1 : let deser = SafeKeeperStateV4::des(&ser).unwrap();
671 1 :
672 1 : assert_eq!(state, deser);
673 1 : }
674 : }
|
