Line data Source code
1 : //! Types used in safekeeper http API. Many of them are also reused internally.
2 :
3 : use postgres_ffi::TimestampTz;
4 : use serde::{Deserialize, Serialize};
5 : use std::net::SocketAddr;
6 : use tokio::time::Instant;
7 :
8 : use utils::{
9 : id::{NodeId, TenantId, TenantTimelineId, TimelineId},
10 : lsn::Lsn,
11 : pageserver_feedback::PageserverFeedback,
12 : };
13 :
14 : use crate::{ServerInfo, Term};
15 :
16 : #[derive(Debug, Serialize)]
17 : pub struct SafekeeperStatus {
18 : pub id: NodeId,
19 : }
20 :
21 0 : #[derive(Serialize, Deserialize)]
22 : pub struct TimelineCreateRequest {
23 : pub tenant_id: TenantId,
24 : pub timeline_id: TimelineId,
25 : pub peer_ids: Option<Vec<NodeId>>,
26 : pub pg_version: u32,
27 : pub system_id: Option<u64>,
28 : pub wal_seg_size: Option<u32>,
29 : pub commit_lsn: Lsn,
30 : // If not passed, it is assigned to the beginning of commit_lsn segment.
31 : pub local_start_lsn: Option<Lsn>,
32 : }
33 :
34 : /// Same as TermLsn, but serializes LSN using display serializer
35 : /// in Postgres format, i.e. 0/FFFFFFFF. Used only for the API response.
36 0 : #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
37 : pub struct TermSwitchApiEntry {
38 : pub term: Term,
39 : pub lsn: Lsn,
40 : }
41 :
42 : /// Augment AcceptorState with last_log_term for convenience
43 0 : #[derive(Debug, Serialize, Deserialize)]
44 : pub struct AcceptorStateStatus {
45 : pub term: Term,
46 : pub epoch: Term, // aka last_log_term, old `epoch` name is left for compatibility
47 : pub term_history: Vec<TermSwitchApiEntry>,
48 : }
49 :
50 : /// Things safekeeper should know about timeline state on peers.
51 : /// Used as both model and internally.
52 0 : #[derive(Debug, Clone, Serialize, Deserialize)]
53 : pub struct PeerInfo {
54 : pub sk_id: NodeId,
55 : pub term: Term,
56 : /// Term of the last entry.
57 : pub last_log_term: Term,
58 : /// LSN of the last record.
59 : pub flush_lsn: Lsn,
60 : pub commit_lsn: Lsn,
61 : /// Since which LSN safekeeper has WAL.
62 : pub local_start_lsn: Lsn,
63 : /// When info was received. Serde annotations are not very useful but make
64 : /// the code compile -- we don't rely on this field externally.
65 : #[serde(skip)]
66 : #[serde(default = "Instant::now")]
67 : pub ts: Instant,
68 : pub pg_connstr: String,
69 : pub http_connstr: String,
70 : }
71 :
72 : pub type FullTransactionId = u64;
73 :
74 : /// Hot standby feedback received from replica
75 0 : #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
76 : pub struct HotStandbyFeedback {
77 : pub ts: TimestampTz,
78 : pub xmin: FullTransactionId,
79 : pub catalog_xmin: FullTransactionId,
80 : }
81 :
82 : pub const INVALID_FULL_TRANSACTION_ID: FullTransactionId = 0;
83 :
84 : impl HotStandbyFeedback {
85 2183 : pub fn empty() -> HotStandbyFeedback {
86 2183 : HotStandbyFeedback {
87 2183 : ts: 0,
88 2183 : xmin: 0,
89 2183 : catalog_xmin: 0,
90 2183 : }
91 2183 : }
92 : }
93 :
94 : /// Standby status update
95 0 : #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
96 : pub struct StandbyReply {
97 : pub write_lsn: Lsn, // The location of the last WAL byte + 1 received and written to disk in the standby.
98 : pub flush_lsn: Lsn, // The location of the last WAL byte + 1 flushed to disk in the standby.
99 : pub apply_lsn: Lsn, // The location of the last WAL byte + 1 applied in the standby.
100 : pub reply_ts: TimestampTz, // The client's system clock at the time of transmission, as microseconds since midnight on 2000-01-01.
101 : pub reply_requested: bool,
102 : }
103 :
104 : impl StandbyReply {
105 8 : pub fn empty() -> Self {
106 8 : StandbyReply {
107 8 : write_lsn: Lsn::INVALID,
108 8 : flush_lsn: Lsn::INVALID,
109 8 : apply_lsn: Lsn::INVALID,
110 8 : reply_ts: 0,
111 8 : reply_requested: false,
112 8 : }
113 8 : }
114 : }
115 :
116 0 : #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
117 : pub struct StandbyFeedback {
118 : pub reply: StandbyReply,
119 : pub hs_feedback: HotStandbyFeedback,
120 : }
121 :
122 : impl StandbyFeedback {
123 2 : pub fn empty() -> Self {
124 2 : StandbyFeedback {
125 2 : reply: StandbyReply::empty(),
126 2 : hs_feedback: HotStandbyFeedback::empty(),
127 2 : }
128 2 : }
129 : }
130 :
131 : /// Receiver is either pageserver or regular standby, which have different
132 : /// feedbacks.
133 : /// Used as both model and internally.
134 0 : #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
135 : pub enum ReplicationFeedback {
136 : Pageserver(PageserverFeedback),
137 : Standby(StandbyFeedback),
138 : }
139 :
140 : /// Uniquely identifies a WAL service connection. Logged in spans for
141 : /// observability.
142 : pub type ConnectionId = u32;
143 :
144 : /// Serialize is used only for json'ing in API response. Also used internally.
145 0 : #[derive(Debug, Clone, Serialize, Deserialize)]
146 : pub struct WalSenderState {
147 : pub ttid: TenantTimelineId,
148 : pub addr: SocketAddr,
149 : pub conn_id: ConnectionId,
150 : // postgres application_name
151 : pub appname: Option<String>,
152 : pub feedback: ReplicationFeedback,
153 : }
154 :
155 0 : #[derive(Debug, Clone, Serialize, Deserialize)]
156 : pub struct WalReceiverState {
157 : /// None means it is recovery initiated by us (this safekeeper).
158 : pub conn_id: Option<ConnectionId>,
159 : pub status: WalReceiverStatus,
160 : }
161 :
162 : /// Walreceiver status. Currently only whether it passed voting stage and
163 : /// started receiving the stream, but it is easy to add more if needed.
164 0 : #[derive(Debug, Clone, Serialize, Deserialize)]
165 : pub enum WalReceiverStatus {
166 : Voting,
167 : Streaming,
168 : }
169 :
170 : /// Info about timeline on safekeeper ready for reporting.
171 0 : #[derive(Debug, Serialize, Deserialize)]
172 : pub struct TimelineStatus {
173 : pub tenant_id: TenantId,
174 : pub timeline_id: TimelineId,
175 : pub acceptor_state: AcceptorStateStatus,
176 : pub pg_info: ServerInfo,
177 : pub flush_lsn: Lsn,
178 : pub timeline_start_lsn: Lsn,
179 : pub local_start_lsn: Lsn,
180 : pub commit_lsn: Lsn,
181 : pub backup_lsn: Lsn,
182 : pub peer_horizon_lsn: Lsn,
183 : pub remote_consistent_lsn: Lsn,
184 : pub peers: Vec<PeerInfo>,
185 : pub walsenders: Vec<WalSenderState>,
186 : pub walreceivers: Vec<WalReceiverState>,
187 : }
188 :
189 0 : fn lsn_invalid() -> Lsn {
190 0 : Lsn::INVALID
191 0 : }
192 :
193 : /// Data about safekeeper's timeline, mirrors broker.proto.
194 0 : #[derive(Debug, Clone, Deserialize, Serialize)]
195 : pub struct SkTimelineInfo {
196 : /// Term.
197 : pub term: Option<u64>,
198 : /// Term of the last entry.
199 : pub last_log_term: Option<u64>,
200 : /// LSN of the last record.
201 : #[serde(default = "lsn_invalid")]
202 : pub flush_lsn: Lsn,
203 : /// Up to which LSN safekeeper regards its WAL as committed.
204 : #[serde(default = "lsn_invalid")]
205 : pub commit_lsn: Lsn,
206 : /// LSN up to which safekeeper has backed WAL.
207 : #[serde(default = "lsn_invalid")]
208 : pub backup_lsn: Lsn,
209 : /// LSN of last checkpoint uploaded by pageserver.
210 : #[serde(default = "lsn_invalid")]
211 : pub remote_consistent_lsn: Lsn,
212 : #[serde(default = "lsn_invalid")]
213 : pub peer_horizon_lsn: Lsn,
214 : #[serde(default = "lsn_invalid")]
215 : pub local_start_lsn: Lsn,
216 : /// A connection string to use for WAL receiving.
217 : #[serde(default)]
218 : pub safekeeper_connstr: Option<String>,
219 : #[serde(default)]
220 : pub http_connstr: Option<String>,
221 : // Minimum of all active RO replicas flush LSN
222 : #[serde(default = "lsn_invalid")]
223 : pub standby_horizon: Lsn,
224 : }
225 :
226 0 : #[derive(Debug, Clone, Deserialize, Serialize)]
227 : pub struct TimelineCopyRequest {
228 : pub target_timeline_id: TimelineId,
229 : pub until_lsn: Lsn,
230 : }
231 :
232 0 : #[derive(Debug, Clone, Deserialize, Serialize)]
233 : pub struct TimelineTermBumpRequest {
234 : /// bump to
235 : pub term: Option<u64>,
236 : }
237 :
238 0 : #[derive(Debug, Clone, Deserialize, Serialize)]
239 : pub struct TimelineTermBumpResponse {
240 : // before the request
241 : pub previous_term: u64,
242 : pub current_term: u64,
243 : }
|
