Line data Source code
1 : pub mod partitioning;
2 :
3 : use std::{
4 : collections::HashMap,
5 : io::{BufRead, Read},
6 : num::{NonZeroU64, NonZeroUsize},
7 : time::{Duration, SystemTime},
8 : };
9 :
10 : use byteorder::{BigEndian, ReadBytesExt};
11 : use postgres_ffi::BLCKSZ;
12 : use serde::{Deserialize, Serialize};
13 : use serde_with::serde_as;
14 : use strum_macros;
15 : use utils::{
16 : completion,
17 : history_buffer::HistoryBufferWithDropCounter,
18 : id::{NodeId, TenantId, TimelineId},
19 : lsn::Lsn,
20 : };
21 :
22 : use crate::{
23 : reltag::RelTag,
24 : shard::{ShardCount, ShardStripeSize, TenantShardId},
25 : };
26 : use anyhow::bail;
27 : use bytes::{Buf, BufMut, Bytes, BytesMut};
28 :
29 : /// The state of a tenant in this pageserver.
30 : ///
31 : /// ```mermaid
32 : /// stateDiagram-v2
33 : ///
34 : /// [*] --> Loading: spawn_load()
35 : /// [*] --> Attaching: spawn_attach()
36 : ///
37 : /// Loading --> Activating: activate()
38 : /// Attaching --> Activating: activate()
39 : /// Activating --> Active: infallible
40 : ///
41 : /// Loading --> Broken: load() failure
42 : /// Attaching --> Broken: attach() failure
43 : ///
44 : /// Active --> Stopping: set_stopping(), part of shutdown & detach
45 : /// Stopping --> Broken: late error in remove_tenant_from_memory
46 : ///
47 : /// Broken --> [*]: ignore / detach / shutdown
48 : /// Stopping --> [*]: remove_from_memory complete
49 : ///
50 : /// Active --> Broken: cfg(testing)-only tenant break point
51 : /// ```
52 : #[derive(
53 36917 : Clone,
54 5154 : PartialEq,
55 : Eq,
56 892 : serde::Serialize,
57 34 : serde::Deserialize,
58 17 : strum_macros::Display,
59 : strum_macros::EnumVariantNames,
60 0 : strum_macros::AsRefStr,
61 3531 : strum_macros::IntoStaticStr,
62 : )]
63 : #[serde(tag = "slug", content = "data")]
64 : pub enum TenantState {
65 : /// This tenant is being loaded from local disk.
66 : ///
67 : /// `set_stopping()` and `set_broken()` do not work in this state and wait for it to pass.
68 : Loading,
69 : /// This tenant is being attached to the pageserver.
70 : ///
71 : /// `set_stopping()` and `set_broken()` do not work in this state and wait for it to pass.
72 : Attaching,
73 : /// The tenant is transitioning from Loading/Attaching to Active.
74 : ///
75 : /// While in this state, the individual timelines are being activated.
76 : ///
77 : /// `set_stopping()` and `set_broken()` do not work in this state and wait for it to pass.
78 : Activating(ActivatingFrom),
79 : /// The tenant has finished activating and is open for business.
80 : ///
81 : /// Transitions out of this state are possible through `set_stopping()` and `set_broken()`.
82 : Active,
83 : /// The tenant is recognized by pageserver, but it is being detached or the
84 : /// system is being shut down.
85 : ///
86 : /// Transitions out of this state are possible through `set_broken()`.
87 : Stopping {
88 : // Because of https://github.com/serde-rs/serde/issues/2105 this has to be a named field,
89 : // otherwise it will not be skipped during deserialization
90 : #[serde(skip)]
91 : progress: completion::Barrier,
92 : },
93 : /// The tenant is recognized by the pageserver, but can no longer be used for
94 : /// any operations.
95 : ///
96 : /// If the tenant fails to load or attach, it will transition to this state
97 : /// and it is guaranteed that no background tasks are running in its name.
98 : ///
99 : /// The other way to transition into this state is from `Stopping` state
100 : /// through `set_broken()` called from `remove_tenant_from_memory()`. That happens
101 : /// if the cleanup future executed by `remove_tenant_from_memory()` fails.
102 : Broken { reason: String, backtrace: String },
103 : }
104 :
105 : impl TenantState {
106 658 : pub fn attachment_status(&self) -> TenantAttachmentStatus {
107 : use TenantAttachmentStatus::*;
108 :
109 : // Below TenantState::Activating is used as "transient" or "transparent" state for
110 : // attachment_status determining.
111 0 : match self {
112 : // The attach procedure writes the marker file before adding the Attaching tenant to the tenants map.
113 : // So, technically, we can return Attached here.
114 : // However, as soon as Console observes Attached, it will proceed with the Postgres-level health check.
115 : // But, our attach task might still be fetching the remote timelines, etc.
116 : // So, return `Maybe` while Attaching, making Console wait for the attach task to finish.
117 214 : Self::Attaching | Self::Activating(ActivatingFrom::Attaching) => Maybe,
118 : // tenant mgr startup distinguishes attaching from loading via marker file.
119 0 : Self::Loading | Self::Activating(ActivatingFrom::Loading) => Attached,
120 : // We only reach Active after successful load / attach.
121 : // So, call atttachment status Attached.
122 220 : Self::Active => Attached,
123 : // If the (initial or resumed) attach procedure fails, the tenant becomes Broken.
124 : // However, it also becomes Broken if the regular load fails.
125 : // From Console's perspective there's no practical difference
126 : // because attachment_status is polled by console only during attach operation execution.
127 106 : Self::Broken { reason, .. } => Failed {
128 106 : reason: reason.to_owned(),
129 106 : },
130 : // Why is Stopping a Maybe case? Because, during pageserver shutdown,
131 : // we set the Stopping state irrespective of whether the tenant
132 : // has finished attaching or not.
133 118 : Self::Stopping { .. } => Maybe,
134 : }
135 658 : }
136 :
137 58 : pub fn broken_from_reason(reason: String) -> Self {
138 58 : let backtrace_str: String = format!("{}", std::backtrace::Backtrace::force_capture());
139 58 : Self::Broken {
140 58 : reason,
141 58 : backtrace: backtrace_str,
142 58 : }
143 58 : }
144 : }
145 :
146 : impl std::fmt::Debug for TenantState {
147 16 : fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
148 4 : match self {
149 4 : Self::Broken { reason, backtrace } if !reason.is_empty() => {
150 4 : write!(f, "Broken due to: {reason}. Backtrace:\n{backtrace}")
151 : }
152 12 : _ => write!(f, "{self}"),
153 : }
154 16 : }
155 : }
156 :
157 : /// The only [`TenantState`] variants we could be `TenantState::Activating` from.
158 573 : #[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
159 : pub enum ActivatingFrom {
160 : /// Arrived to [`TenantState::Activating`] from [`TenantState::Loading`]
161 : Loading,
162 : /// Arrived to [`TenantState::Activating`] from [`TenantState::Attaching`]
163 : Attaching,
164 : }
165 :
166 : /// A state of a timeline in pageserver's memory.
167 3564603 : #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
168 : pub enum TimelineState {
169 : /// The timeline is recognized by the pageserver but is not yet operational.
170 : /// In particular, the walreceiver connection loop is not running for this timeline.
171 : /// It will eventually transition to state Active or Broken.
172 : Loading,
173 : /// The timeline is fully operational.
174 : /// It can be queried, and the walreceiver connection loop is running.
175 : Active,
176 : /// The timeline was previously Loading or Active but is shutting down.
177 : /// It cannot transition back into any other state.
178 : Stopping,
179 : /// The timeline is broken and not operational (previous states: Loading or Active).
180 : Broken { reason: String, backtrace: String },
181 : }
182 :
183 18574 : #[derive(Serialize, Deserialize)]
184 : pub struct TimelineCreateRequest {
185 : pub new_timeline_id: TimelineId,
186 : #[serde(default)]
187 : pub ancestor_timeline_id: Option<TimelineId>,
188 : #[serde(default)]
189 : pub existing_initdb_timeline_id: Option<TimelineId>,
190 : #[serde(default)]
191 : pub ancestor_start_lsn: Option<Lsn>,
192 : pub pg_version: Option<u32>,
193 : }
194 :
195 21 : #[derive(Serialize, Deserialize)]
196 : pub struct TenantShardSplitRequest {
197 : pub new_shard_count: u8,
198 : }
199 :
200 15 : #[derive(Serialize, Deserialize)]
201 : pub struct TenantShardSplitResponse {
202 : pub new_shards: Vec<TenantShardId>,
203 : }
204 :
205 : /// Parameters that apply to all shards in a tenant. Used during tenant creation.
206 2950 : #[derive(Serialize, Deserialize, Debug)]
207 : #[serde(deny_unknown_fields)]
208 : pub struct ShardParameters {
209 : pub count: ShardCount,
210 : pub stripe_size: ShardStripeSize,
211 : }
212 :
213 : impl ShardParameters {
214 : pub const DEFAULT_STRIPE_SIZE: ShardStripeSize = ShardStripeSize(256 * 1024 / 8);
215 :
216 924 : pub fn is_unsharded(&self) -> bool {
217 924 : self.count == ShardCount(0)
218 924 : }
219 : }
220 :
221 : impl Default for ShardParameters {
222 723 : fn default() -> Self {
223 723 : Self {
224 723 : count: ShardCount(0),
225 723 : stripe_size: Self::DEFAULT_STRIPE_SIZE,
226 723 : }
227 723 : }
228 : }
229 :
230 11368 : #[derive(Serialize, Deserialize, Debug)]
231 : #[serde(deny_unknown_fields)]
232 : pub struct TenantCreateRequest {
233 : pub new_tenant_id: TenantShardId,
234 : #[serde(default)]
235 : #[serde(skip_serializing_if = "Option::is_none")]
236 : pub generation: Option<u32>,
237 :
238 : // If omitted, create a single shard with TenantShardId::unsharded()
239 : #[serde(default)]
240 : #[serde(skip_serializing_if = "ShardParameters::is_unsharded")]
241 : pub shard_parameters: ShardParameters,
242 :
243 : #[serde(flatten)]
244 : pub config: TenantConfig, // as we have a flattened field, we should reject all unknown fields in it
245 : }
246 :
247 12 : #[derive(Deserialize, Debug)]
248 : #[serde(deny_unknown_fields)]
249 : pub struct TenantLoadRequest {
250 : #[serde(default)]
251 : #[serde(skip_serializing_if = "Option::is_none")]
252 : pub generation: Option<u32>,
253 : }
254 :
255 : impl std::ops::Deref for TenantCreateRequest {
256 : type Target = TenantConfig;
257 :
258 0 : fn deref(&self) -> &Self::Target {
259 0 : &self.config
260 0 : }
261 : }
262 :
263 : /// An alternative representation of `pageserver::tenant::TenantConf` with
264 : /// simpler types.
265 40038 : #[derive(Serialize, Deserialize, Debug, Default, Clone, Eq, PartialEq)]
266 : pub struct TenantConfig {
267 : pub checkpoint_distance: Option<u64>,
268 : pub checkpoint_timeout: Option<String>,
269 : pub compaction_target_size: Option<u64>,
270 : pub compaction_period: Option<String>,
271 : pub compaction_threshold: Option<usize>,
272 : pub gc_horizon: Option<u64>,
273 : pub gc_period: Option<String>,
274 : pub image_creation_threshold: Option<usize>,
275 : pub pitr_interval: Option<String>,
276 : pub walreceiver_connect_timeout: Option<String>,
277 : pub lagging_wal_timeout: Option<String>,
278 : pub max_lsn_wal_lag: Option<NonZeroU64>,
279 : pub trace_read_requests: Option<bool>,
280 : pub eviction_policy: Option<EvictionPolicy>,
281 : pub min_resident_size_override: Option<u64>,
282 : pub evictions_low_residence_duration_metric_threshold: Option<String>,
283 : pub gc_feedback: Option<bool>,
284 : pub heatmap_period: Option<String>,
285 : pub lazy_slru_download: Option<bool>,
286 : }
287 :
288 80 : #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
289 : #[serde(tag = "kind")]
290 : pub enum EvictionPolicy {
291 : NoEviction,
292 : LayerAccessThreshold(EvictionPolicyLayerAccessThreshold),
293 : }
294 :
295 : impl EvictionPolicy {
296 1408 : pub fn discriminant_str(&self) -> &'static str {
297 1408 : match self {
298 1376 : EvictionPolicy::NoEviction => "NoEviction",
299 32 : EvictionPolicy::LayerAccessThreshold(_) => "LayerAccessThreshold",
300 : }
301 1408 : }
302 : }
303 :
304 133 : #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
305 : pub struct EvictionPolicyLayerAccessThreshold {
306 : #[serde(with = "humantime_serde")]
307 : pub period: Duration,
308 : #[serde(with = "humantime_serde")]
309 : pub threshold: Duration,
310 : }
311 :
312 : /// A flattened analog of a `pagesever::tenant::LocationMode`, which
313 : /// lists out all possible states (and the virtual "Detached" state)
314 : /// in a flat form rather than using rust-style enums.
315 1552 : #[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
316 : pub enum LocationConfigMode {
317 : AttachedSingle,
318 : AttachedMulti,
319 : AttachedStale,
320 : Secondary,
321 : Detached,
322 : }
323 :
324 102 : #[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
325 : pub struct LocationConfigSecondary {
326 : pub warm: bool,
327 : }
328 :
329 : /// An alternative representation of `pageserver::tenant::LocationConf`,
330 : /// for use in external-facing APIs.
331 9378 : #[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
332 : pub struct LocationConfig {
333 : pub mode: LocationConfigMode,
334 : /// If attaching, in what generation?
335 : #[serde(default)]
336 : pub generation: Option<u32>,
337 :
338 : // If requesting mode `Secondary`, configuration for that.
339 : #[serde(default)]
340 : pub secondary_conf: Option<LocationConfigSecondary>,
341 :
342 : // Shard parameters: if shard_count is nonzero, then other shard_* fields
343 : // must be set accurately.
344 : #[serde(default)]
345 : pub shard_number: u8,
346 : #[serde(default)]
347 : pub shard_count: u8,
348 : #[serde(default)]
349 : pub shard_stripe_size: u32,
350 :
351 : // This configuration only affects attached mode, but should be provided irrespective
352 : // of the mode, as a secondary location might transition on startup if the response
353 : // to the `/re-attach` control plane API requests it.
354 : pub tenant_conf: TenantConfig,
355 : }
356 :
357 18 : #[derive(Serialize, Deserialize)]
358 : pub struct LocationConfigListResponse {
359 : pub tenant_shards: Vec<(TenantShardId, Option<LocationConfig>)>,
360 : }
361 :
362 39 : #[derive(Serialize, Deserialize)]
363 : #[serde(transparent)]
364 : pub struct TenantCreateResponse(pub TenantId);
365 :
366 631 : #[derive(Serialize)]
367 : pub struct StatusResponse {
368 : pub id: NodeId,
369 : }
370 :
371 7063 : #[derive(Serialize, Deserialize, Debug)]
372 : #[serde(deny_unknown_fields)]
373 : pub struct TenantLocationConfigRequest {
374 : pub tenant_id: TenantShardId,
375 : #[serde(flatten)]
376 : pub config: LocationConfig, // as we have a flattened field, we should reject all unknown fields in it
377 : }
378 :
379 598 : #[derive(Serialize, Deserialize, Debug)]
380 : #[serde(deny_unknown_fields)]
381 : pub struct TenantShardLocation {
382 : pub shard_id: TenantShardId,
383 : pub node_id: NodeId,
384 : }
385 :
386 632 : #[derive(Serialize, Deserialize, Debug)]
387 : #[serde(deny_unknown_fields)]
388 : pub struct TenantLocationConfigResponse {
389 : pub shards: Vec<TenantShardLocation>,
390 : }
391 :
392 457 : #[derive(Serialize, Deserialize, Debug)]
393 : #[serde(deny_unknown_fields)]
394 : pub struct TenantConfigRequest {
395 : pub tenant_id: TenantId,
396 : #[serde(flatten)]
397 : pub config: TenantConfig, // as we have a flattened field, we should reject all unknown fields in it
398 : }
399 :
400 : impl std::ops::Deref for TenantConfigRequest {
401 : type Target = TenantConfig;
402 :
403 0 : fn deref(&self) -> &Self::Target {
404 0 : &self.config
405 0 : }
406 : }
407 :
408 : impl TenantConfigRequest {
409 0 : pub fn new(tenant_id: TenantId) -> TenantConfigRequest {
410 0 : let config = TenantConfig::default();
411 0 : TenantConfigRequest { tenant_id, config }
412 0 : }
413 : }
414 :
415 202 : #[derive(Debug, Deserialize)]
416 : pub struct TenantAttachRequest {
417 : #[serde(default)]
418 : pub config: TenantAttachConfig,
419 : #[serde(default)]
420 : pub generation: Option<u32>,
421 : }
422 :
423 : /// Newtype to enforce deny_unknown_fields on TenantConfig for
424 : /// its usage inside `TenantAttachRequest`.
425 75 : #[derive(Debug, Serialize, Deserialize, Default)]
426 : #[serde(deny_unknown_fields)]
427 : pub struct TenantAttachConfig {
428 : #[serde(flatten)]
429 : allowing_unknown_fields: TenantConfig,
430 : }
431 :
432 : impl std::ops::Deref for TenantAttachConfig {
433 : type Target = TenantConfig;
434 :
435 38 : fn deref(&self) -> &Self::Target {
436 38 : &self.allowing_unknown_fields
437 38 : }
438 : }
439 :
440 : /// See [`TenantState::attachment_status`] and the OpenAPI docs for context.
441 768 : #[derive(Serialize, Deserialize, Clone)]
442 : #[serde(tag = "slug", content = "data", rename_all = "snake_case")]
443 : pub enum TenantAttachmentStatus {
444 : Maybe,
445 : Attached,
446 : Failed { reason: String },
447 : }
448 :
449 662 : #[derive(Serialize, Deserialize, Clone)]
450 : pub struct TenantInfo {
451 : pub id: TenantShardId,
452 : // NB: intentionally not part of OpenAPI, we don't want to commit to a specific set of TenantState's
453 : pub state: TenantState,
454 : /// Sum of the size of all layer files.
455 : /// If a layer is present in both local FS and S3, it counts only once.
456 : pub current_physical_size: Option<u64>, // physical size is only included in `tenant_status` endpoint
457 : pub attachment_status: TenantAttachmentStatus,
458 : #[serde(skip_serializing_if = "Option::is_none")]
459 : pub generation: Option<u32>,
460 : }
461 :
462 482 : #[derive(Serialize, Deserialize, Clone)]
463 : pub struct TenantDetails {
464 : #[serde(flatten)]
465 : pub tenant_info: TenantInfo,
466 :
467 : pub walredo: Option<WalRedoManagerStatus>,
468 :
469 : pub timelines: Vec<TimelineId>,
470 : }
471 :
472 : /// This represents the output of the "timeline_detail" and "timeline_list" API calls.
473 77926 : #[derive(Debug, Serialize, Deserialize, Clone)]
474 : pub struct TimelineInfo {
475 : pub tenant_id: TenantShardId,
476 : pub timeline_id: TimelineId,
477 :
478 : pub ancestor_timeline_id: Option<TimelineId>,
479 : pub ancestor_lsn: Option<Lsn>,
480 : pub last_record_lsn: Lsn,
481 : pub prev_record_lsn: Option<Lsn>,
482 : pub latest_gc_cutoff_lsn: Lsn,
483 : pub disk_consistent_lsn: Lsn,
484 :
485 : /// The LSN that we have succesfully uploaded to remote storage
486 : pub remote_consistent_lsn: Lsn,
487 :
488 : /// The LSN that we are advertizing to safekeepers
489 : pub remote_consistent_lsn_visible: Lsn,
490 :
491 : /// The LSN from the start of the root timeline (never changes)
492 : pub initdb_lsn: Lsn,
493 :
494 : pub current_logical_size: u64,
495 : pub current_logical_size_is_accurate: bool,
496 :
497 : pub directory_entries_counts: Vec<u64>,
498 :
499 : /// Sum of the size of all layer files.
500 : /// If a layer is present in both local FS and S3, it counts only once.
501 : pub current_physical_size: Option<u64>, // is None when timeline is Unloaded
502 : pub current_logical_size_non_incremental: Option<u64>,
503 :
504 : pub timeline_dir_layer_file_size_sum: Option<u64>,
505 :
506 : pub wal_source_connstr: Option<String>,
507 : pub last_received_msg_lsn: Option<Lsn>,
508 : /// the timestamp (in microseconds) of the last received message
509 : pub last_received_msg_ts: Option<u128>,
510 : pub pg_version: u32,
511 :
512 : pub state: TimelineState,
513 :
514 : pub walreceiver_status: String,
515 : }
516 :
517 97 : #[derive(Debug, Clone, Serialize)]
518 : pub struct LayerMapInfo {
519 : pub in_memory_layers: Vec<InMemoryLayerInfo>,
520 : pub historic_layers: Vec<HistoricLayerInfo>,
521 : }
522 :
523 33778312 : #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy, Serialize, Deserialize, enum_map::Enum)]
524 : #[repr(usize)]
525 : pub enum LayerAccessKind {
526 : GetValueReconstructData,
527 : Iter,
528 : KeyIter,
529 : Dump,
530 : }
531 :
532 10737 : #[derive(Debug, Clone, Serialize, Deserialize)]
533 : pub struct LayerAccessStatFullDetails {
534 : pub when_millis_since_epoch: u64,
535 : pub task_kind: &'static str,
536 : pub access_kind: LayerAccessKind,
537 : }
538 :
539 : /// An event that impacts the layer's residence status.
540 : #[serde_as]
541 7054 : #[derive(Debug, Clone, Serialize, Deserialize)]
542 : pub struct LayerResidenceEvent {
543 : /// The time when the event occurred.
544 : /// NB: this timestamp is captured while the residence status changes.
545 : /// So, it might be behind/ahead of the actual residence change by a short amount of time.
546 : ///
547 : #[serde(rename = "timestamp_millis_since_epoch")]
548 : #[serde_as(as = "serde_with::TimestampMilliSeconds")]
549 : pub timestamp: SystemTime,
550 : /// The new residence status of the layer.
551 : pub status: LayerResidenceStatus,
552 : /// The reason why we had to record this event.
553 : pub reason: LayerResidenceEventReason,
554 : }
555 :
556 : /// The reason for recording a given [`LayerResidenceEvent`].
557 7054 : #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
558 : pub enum LayerResidenceEventReason {
559 : /// The layer map is being populated, e.g. during timeline load or attach.
560 : /// This includes [`RemoteLayer`] objects created in [`reconcile_with_remote`].
561 : /// We need to record such events because there is no persistent storage for the events.
562 : ///
563 : // https://github.com/rust-lang/rust/issues/74481
564 : /// [`RemoteLayer`]: ../../tenant/storage_layer/struct.RemoteLayer.html
565 : /// [`reconcile_with_remote`]: ../../tenant/struct.Timeline.html#method.reconcile_with_remote
566 : LayerLoad,
567 : /// We just created the layer (e.g., freeze_and_flush or compaction).
568 : /// Such layers are always [`LayerResidenceStatus::Resident`].
569 : LayerCreate,
570 : /// We on-demand downloaded or evicted the given layer.
571 : ResidenceChange,
572 : }
573 :
574 : /// The residence status of the layer, after the given [`LayerResidenceEvent`].
575 7054 : #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
576 : pub enum LayerResidenceStatus {
577 : /// Residence status for a layer file that exists locally.
578 : /// It may also exist on the remote, we don't care here.
579 : Resident,
580 : /// Residence status for a layer file that only exists on the remote.
581 : Evicted,
582 : }
583 :
584 : impl LayerResidenceEvent {
585 174654 : pub fn new(status: LayerResidenceStatus, reason: LayerResidenceEventReason) -> Self {
586 174654 : Self {
587 174654 : status,
588 174654 : reason,
589 174654 : timestamp: SystemTime::now(),
590 174654 : }
591 174654 : }
592 : }
593 :
594 3050 : #[derive(Debug, Clone, Serialize)]
595 : pub struct LayerAccessStats {
596 : pub access_count_by_access_kind: HashMap<LayerAccessKind, u64>,
597 : pub task_kind_access_flag: Vec<&'static str>,
598 : pub first: Option<LayerAccessStatFullDetails>,
599 : pub accesses_history: HistoryBufferWithDropCounter<LayerAccessStatFullDetails, 16>,
600 : pub residence_events_history: HistoryBufferWithDropCounter<LayerResidenceEvent, 16>,
601 : }
602 :
603 3 : #[derive(Debug, Clone, Serialize)]
604 : #[serde(tag = "kind")]
605 : pub enum InMemoryLayerInfo {
606 : Open { lsn_start: Lsn },
607 : Frozen { lsn_start: Lsn, lsn_end: Lsn },
608 : }
609 :
610 3050 : #[derive(Debug, Clone, Serialize)]
611 : #[serde(tag = "kind")]
612 : pub enum HistoricLayerInfo {
613 : Delta {
614 : layer_file_name: String,
615 : layer_file_size: u64,
616 :
617 : lsn_start: Lsn,
618 : lsn_end: Lsn,
619 : remote: bool,
620 : access_stats: LayerAccessStats,
621 : },
622 : Image {
623 : layer_file_name: String,
624 : layer_file_size: u64,
625 :
626 : lsn_start: Lsn,
627 : remote: bool,
628 : access_stats: LayerAccessStats,
629 : },
630 : }
631 :
632 6 : #[derive(Debug, Serialize, Deserialize)]
633 : pub struct DownloadRemoteLayersTaskSpawnRequest {
634 : pub max_concurrent_downloads: NonZeroUsize,
635 : }
636 :
637 57 : #[derive(Debug, Serialize, Deserialize, Clone)]
638 : pub struct DownloadRemoteLayersTaskInfo {
639 : pub task_id: String,
640 : pub state: DownloadRemoteLayersTaskState,
641 : pub total_layer_count: u64, // stable once `completed`
642 : pub successful_download_count: u64, // stable once `completed`
643 : pub failed_download_count: u64, // stable once `completed`
644 : }
645 :
646 57 : #[derive(Debug, Serialize, Deserialize, Clone)]
647 : pub enum DownloadRemoteLayersTaskState {
648 : Running,
649 : Completed,
650 : ShutDown,
651 : }
652 :
653 972 : #[derive(Debug, Serialize, Deserialize)]
654 : pub struct TimelineGcRequest {
655 : pub gc_horizon: Option<u64>,
656 : }
657 :
658 482 : #[derive(Debug, Clone, Serialize, Deserialize)]
659 : pub struct WalRedoManagerStatus {
660 : pub last_redo_at: Option<chrono::DateTime<chrono::Utc>>,
661 : pub pid: Option<u32>,
662 : }
663 :
664 : pub mod virtual_file {
665 : #[derive(
666 : Copy,
667 0 : Clone,
668 4 : PartialEq,
669 : Eq,
670 0 : Hash,
671 1237 : strum_macros::EnumString,
672 625 : strum_macros::Display,
673 0 : serde_with::DeserializeFromStr,
674 0 : serde_with::SerializeDisplay,
675 0 : Debug,
676 : )]
677 : #[strum(serialize_all = "kebab-case")]
678 : pub enum IoEngineKind {
679 : StdFs,
680 : #[cfg(target_os = "linux")]
681 : TokioEpollUring,
682 : }
683 : }
684 :
685 : // Wrapped in libpq CopyData
686 8 : #[derive(PartialEq, Eq, Debug)]
687 : pub enum PagestreamFeMessage {
688 : Exists(PagestreamExistsRequest),
689 : Nblocks(PagestreamNblocksRequest),
690 : GetPage(PagestreamGetPageRequest),
691 : DbSize(PagestreamDbSizeRequest),
692 : GetSlruSegment(PagestreamGetSlruSegmentRequest),
693 : }
694 :
695 : // Wrapped in libpq CopyData
696 0 : #[derive(strum_macros::EnumProperty)]
697 : pub enum PagestreamBeMessage {
698 : Exists(PagestreamExistsResponse),
699 : Nblocks(PagestreamNblocksResponse),
700 : GetPage(PagestreamGetPageResponse),
701 : Error(PagestreamErrorResponse),
702 : DbSize(PagestreamDbSizeResponse),
703 : GetSlruSegment(PagestreamGetSlruSegmentResponse),
704 : }
705 :
706 : // Keep in sync with `pagestore_client.h`
707 : #[repr(u8)]
708 : enum PagestreamBeMessageTag {
709 : Exists = 100,
710 : Nblocks = 101,
711 : GetPage = 102,
712 : Error = 103,
713 : DbSize = 104,
714 : GetSlruSegment = 105,
715 : }
716 : impl TryFrom<u8> for PagestreamBeMessageTag {
717 : type Error = u8;
718 0 : fn try_from(value: u8) -> Result<Self, u8> {
719 0 : match value {
720 0 : 100 => Ok(PagestreamBeMessageTag::Exists),
721 0 : 101 => Ok(PagestreamBeMessageTag::Nblocks),
722 0 : 102 => Ok(PagestreamBeMessageTag::GetPage),
723 0 : 103 => Ok(PagestreamBeMessageTag::Error),
724 0 : 104 => Ok(PagestreamBeMessageTag::DbSize),
725 0 : 105 => Ok(PagestreamBeMessageTag::GetSlruSegment),
726 0 : _ => Err(value),
727 : }
728 0 : }
729 : }
730 :
731 2 : #[derive(Debug, PartialEq, Eq)]
732 : pub struct PagestreamExistsRequest {
733 : pub latest: bool,
734 : pub lsn: Lsn,
735 : pub rel: RelTag,
736 : }
737 :
738 2 : #[derive(Debug, PartialEq, Eq)]
739 : pub struct PagestreamNblocksRequest {
740 : pub latest: bool,
741 : pub lsn: Lsn,
742 : pub rel: RelTag,
743 : }
744 :
745 2 : #[derive(Debug, PartialEq, Eq)]
746 : pub struct PagestreamGetPageRequest {
747 : pub latest: bool,
748 : pub lsn: Lsn,
749 : pub rel: RelTag,
750 : pub blkno: u32,
751 : }
752 :
753 2 : #[derive(Debug, PartialEq, Eq)]
754 : pub struct PagestreamDbSizeRequest {
755 : pub latest: bool,
756 : pub lsn: Lsn,
757 : pub dbnode: u32,
758 : }
759 :
760 0 : #[derive(Debug, PartialEq, Eq)]
761 : pub struct PagestreamGetSlruSegmentRequest {
762 : pub latest: bool,
763 : pub lsn: Lsn,
764 : pub kind: u8,
765 : pub segno: u32,
766 : }
767 :
768 0 : #[derive(Debug)]
769 : pub struct PagestreamExistsResponse {
770 : pub exists: bool,
771 : }
772 :
773 0 : #[derive(Debug)]
774 : pub struct PagestreamNblocksResponse {
775 : pub n_blocks: u32,
776 : }
777 :
778 0 : #[derive(Debug)]
779 : pub struct PagestreamGetPageResponse {
780 : pub page: Bytes,
781 : }
782 :
783 0 : #[derive(Debug)]
784 : pub struct PagestreamGetSlruSegmentResponse {
785 : pub segment: Bytes,
786 : }
787 :
788 0 : #[derive(Debug)]
789 : pub struct PagestreamErrorResponse {
790 : pub message: String,
791 : }
792 :
793 0 : #[derive(Debug)]
794 : pub struct PagestreamDbSizeResponse {
795 : pub db_size: i64,
796 : }
797 :
798 : // This is a cut-down version of TenantHistorySize from the pageserver crate, omitting fields
799 : // that require pageserver-internal types. It is sufficient to get the total size.
800 0 : #[derive(Serialize, Deserialize, Debug)]
801 : pub struct TenantHistorySize {
802 : pub id: TenantId,
803 : /// Size is a mixture of WAL and logical size, so the unit is bytes.
804 : ///
805 : /// Will be none if `?inputs_only=true` was given.
806 : pub size: Option<u64>,
807 : }
808 :
809 : impl PagestreamFeMessage {
810 8 : pub fn serialize(&self) -> Bytes {
811 8 : let mut bytes = BytesMut::new();
812 8 :
813 8 : match self {
814 2 : Self::Exists(req) => {
815 2 : bytes.put_u8(0);
816 2 : bytes.put_u8(u8::from(req.latest));
817 2 : bytes.put_u64(req.lsn.0);
818 2 : bytes.put_u32(req.rel.spcnode);
819 2 : bytes.put_u32(req.rel.dbnode);
820 2 : bytes.put_u32(req.rel.relnode);
821 2 : bytes.put_u8(req.rel.forknum);
822 2 : }
823 :
824 2 : Self::Nblocks(req) => {
825 2 : bytes.put_u8(1);
826 2 : bytes.put_u8(u8::from(req.latest));
827 2 : bytes.put_u64(req.lsn.0);
828 2 : bytes.put_u32(req.rel.spcnode);
829 2 : bytes.put_u32(req.rel.dbnode);
830 2 : bytes.put_u32(req.rel.relnode);
831 2 : bytes.put_u8(req.rel.forknum);
832 2 : }
833 :
834 2 : Self::GetPage(req) => {
835 2 : bytes.put_u8(2);
836 2 : bytes.put_u8(u8::from(req.latest));
837 2 : bytes.put_u64(req.lsn.0);
838 2 : bytes.put_u32(req.rel.spcnode);
839 2 : bytes.put_u32(req.rel.dbnode);
840 2 : bytes.put_u32(req.rel.relnode);
841 2 : bytes.put_u8(req.rel.forknum);
842 2 : bytes.put_u32(req.blkno);
843 2 : }
844 :
845 2 : Self::DbSize(req) => {
846 2 : bytes.put_u8(3);
847 2 : bytes.put_u8(u8::from(req.latest));
848 2 : bytes.put_u64(req.lsn.0);
849 2 : bytes.put_u32(req.dbnode);
850 2 : }
851 :
852 0 : Self::GetSlruSegment(req) => {
853 0 : bytes.put_u8(4);
854 0 : bytes.put_u8(u8::from(req.latest));
855 0 : bytes.put_u64(req.lsn.0);
856 0 : bytes.put_u8(req.kind);
857 0 : bytes.put_u32(req.segno);
858 0 : }
859 : }
860 :
861 8 : bytes.into()
862 8 : }
863 :
864 4467214 : pub fn parse<R: std::io::Read>(body: &mut R) -> anyhow::Result<PagestreamFeMessage> {
865 : // TODO these gets can fail
866 :
867 : // these correspond to the NeonMessageTag enum in pagestore_client.h
868 : //
869 : // TODO: consider using protobuf or serde bincode for less error prone
870 : // serialization.
871 4467214 : let msg_tag = body.read_u8()?;
872 4467214 : match msg_tag {
873 : 0 => Ok(PagestreamFeMessage::Exists(PagestreamExistsRequest {
874 56799 : latest: body.read_u8()? != 0,
875 56799 : lsn: Lsn::from(body.read_u64::<BigEndian>()?),
876 : rel: RelTag {
877 56799 : spcnode: body.read_u32::<BigEndian>()?,
878 56799 : dbnode: body.read_u32::<BigEndian>()?,
879 56799 : relnode: body.read_u32::<BigEndian>()?,
880 56799 : forknum: body.read_u8()?,
881 : },
882 : })),
883 : 1 => Ok(PagestreamFeMessage::Nblocks(PagestreamNblocksRequest {
884 20229 : latest: body.read_u8()? != 0,
885 20229 : lsn: Lsn::from(body.read_u64::<BigEndian>()?),
886 : rel: RelTag {
887 20229 : spcnode: body.read_u32::<BigEndian>()?,
888 20229 : dbnode: body.read_u32::<BigEndian>()?,
889 20229 : relnode: body.read_u32::<BigEndian>()?,
890 20229 : forknum: body.read_u8()?,
891 : },
892 : })),
893 : 2 => Ok(PagestreamFeMessage::GetPage(PagestreamGetPageRequest {
894 4390179 : latest: body.read_u8()? != 0,
895 4390179 : lsn: Lsn::from(body.read_u64::<BigEndian>()?),
896 : rel: RelTag {
897 4390179 : spcnode: body.read_u32::<BigEndian>()?,
898 4390179 : dbnode: body.read_u32::<BigEndian>()?,
899 4390179 : relnode: body.read_u32::<BigEndian>()?,
900 4390179 : forknum: body.read_u8()?,
901 : },
902 4390179 : blkno: body.read_u32::<BigEndian>()?,
903 : })),
904 : 3 => Ok(PagestreamFeMessage::DbSize(PagestreamDbSizeRequest {
905 7 : latest: body.read_u8()? != 0,
906 7 : lsn: Lsn::from(body.read_u64::<BigEndian>()?),
907 7 : dbnode: body.read_u32::<BigEndian>()?,
908 : })),
909 : 4 => Ok(PagestreamFeMessage::GetSlruSegment(
910 : PagestreamGetSlruSegmentRequest {
911 0 : latest: body.read_u8()? != 0,
912 0 : lsn: Lsn::from(body.read_u64::<BigEndian>()?),
913 0 : kind: body.read_u8()?,
914 0 : segno: body.read_u32::<BigEndian>()?,
915 : },
916 : )),
917 0 : _ => bail!("unknown smgr message tag: {:?}", msg_tag),
918 : }
919 4467214 : }
920 : }
921 :
922 : impl PagestreamBeMessage {
923 4467197 : pub fn serialize(&self) -> Bytes {
924 4467197 : let mut bytes = BytesMut::new();
925 4467197 :
926 4467197 : use PagestreamBeMessageTag as Tag;
927 4467197 : match self {
928 56797 : Self::Exists(resp) => {
929 56797 : bytes.put_u8(Tag::Exists as u8);
930 56797 : bytes.put_u8(resp.exists as u8);
931 56797 : }
932 :
933 20227 : Self::Nblocks(resp) => {
934 20227 : bytes.put_u8(Tag::Nblocks as u8);
935 20227 : bytes.put_u32(resp.n_blocks);
936 20227 : }
937 :
938 4390167 : Self::GetPage(resp) => {
939 4390167 : bytes.put_u8(Tag::GetPage as u8);
940 4390167 : bytes.put(&resp.page[..]);
941 4390167 : }
942 :
943 1 : Self::Error(resp) => {
944 1 : bytes.put_u8(Tag::Error as u8);
945 1 : bytes.put(resp.message.as_bytes());
946 1 : bytes.put_u8(0); // null terminator
947 1 : }
948 5 : Self::DbSize(resp) => {
949 5 : bytes.put_u8(Tag::DbSize as u8);
950 5 : bytes.put_i64(resp.db_size);
951 5 : }
952 :
953 0 : Self::GetSlruSegment(resp) => {
954 0 : bytes.put_u8(Tag::GetSlruSegment as u8);
955 0 : bytes.put_u32((resp.segment.len() / BLCKSZ as usize) as u32);
956 0 : bytes.put(&resp.segment[..]);
957 0 : }
958 : }
959 :
960 4467197 : bytes.into()
961 4467197 : }
962 :
963 0 : pub fn deserialize(buf: Bytes) -> anyhow::Result<Self> {
964 0 : let mut buf = buf.reader();
965 0 : let msg_tag = buf.read_u8()?;
966 :
967 : use PagestreamBeMessageTag as Tag;
968 0 : let ok =
969 0 : match Tag::try_from(msg_tag).map_err(|tag: u8| anyhow::anyhow!("invalid tag {tag}"))? {
970 : Tag::Exists => {
971 0 : let exists = buf.read_u8()?;
972 0 : Self::Exists(PagestreamExistsResponse {
973 0 : exists: exists != 0,
974 0 : })
975 : }
976 : Tag::Nblocks => {
977 0 : let n_blocks = buf.read_u32::<BigEndian>()?;
978 0 : Self::Nblocks(PagestreamNblocksResponse { n_blocks })
979 : }
980 : Tag::GetPage => {
981 0 : let mut page = vec![0; 8192]; // TODO: use MaybeUninit
982 0 : buf.read_exact(&mut page)?;
983 0 : PagestreamBeMessage::GetPage(PagestreamGetPageResponse { page: page.into() })
984 : }
985 : Tag::Error => {
986 0 : let mut msg = Vec::new();
987 0 : buf.read_until(0, &mut msg)?;
988 0 : let cstring = std::ffi::CString::from_vec_with_nul(msg)?;
989 0 : let rust_str = cstring.to_str()?;
990 0 : PagestreamBeMessage::Error(PagestreamErrorResponse {
991 0 : message: rust_str.to_owned(),
992 0 : })
993 : }
994 : Tag::DbSize => {
995 0 : let db_size = buf.read_i64::<BigEndian>()?;
996 0 : Self::DbSize(PagestreamDbSizeResponse { db_size })
997 : }
998 : Tag::GetSlruSegment => {
999 0 : let n_blocks = buf.read_u32::<BigEndian>()?;
1000 0 : let mut segment = vec![0; n_blocks as usize * BLCKSZ as usize];
1001 0 : buf.read_exact(&mut segment)?;
1002 0 : Self::GetSlruSegment(PagestreamGetSlruSegmentResponse {
1003 0 : segment: segment.into(),
1004 0 : })
1005 : }
1006 : };
1007 0 : let remaining = buf.into_inner();
1008 0 : if !remaining.is_empty() {
1009 0 : anyhow::bail!(
1010 0 : "remaining bytes in msg with tag={msg_tag}: {}",
1011 0 : remaining.len()
1012 0 : );
1013 0 : }
1014 0 : Ok(ok)
1015 0 : }
1016 :
1017 0 : pub fn kind(&self) -> &'static str {
1018 0 : match self {
1019 0 : Self::Exists(_) => "Exists",
1020 0 : Self::Nblocks(_) => "Nblocks",
1021 0 : Self::GetPage(_) => "GetPage",
1022 0 : Self::Error(_) => "Error",
1023 0 : Self::DbSize(_) => "DbSize",
1024 0 : Self::GetSlruSegment(_) => "GetSlruSegment",
1025 : }
1026 0 : }
1027 : }
1028 :
1029 : #[cfg(test)]
1030 : mod tests {
1031 : use bytes::Buf;
1032 : use serde_json::json;
1033 :
1034 : use super::*;
1035 :
1036 2 : #[test]
1037 2 : fn test_pagestream() {
1038 2 : // Test serialization/deserialization of PagestreamFeMessage
1039 2 : let messages = vec![
1040 2 : PagestreamFeMessage::Exists(PagestreamExistsRequest {
1041 2 : latest: true,
1042 2 : lsn: Lsn(4),
1043 2 : rel: RelTag {
1044 2 : forknum: 1,
1045 2 : spcnode: 2,
1046 2 : dbnode: 3,
1047 2 : relnode: 4,
1048 2 : },
1049 2 : }),
1050 2 : PagestreamFeMessage::Nblocks(PagestreamNblocksRequest {
1051 2 : latest: false,
1052 2 : lsn: Lsn(4),
1053 2 : rel: RelTag {
1054 2 : forknum: 1,
1055 2 : spcnode: 2,
1056 2 : dbnode: 3,
1057 2 : relnode: 4,
1058 2 : },
1059 2 : }),
1060 2 : PagestreamFeMessage::GetPage(PagestreamGetPageRequest {
1061 2 : latest: true,
1062 2 : lsn: Lsn(4),
1063 2 : rel: RelTag {
1064 2 : forknum: 1,
1065 2 : spcnode: 2,
1066 2 : dbnode: 3,
1067 2 : relnode: 4,
1068 2 : },
1069 2 : blkno: 7,
1070 2 : }),
1071 2 : PagestreamFeMessage::DbSize(PagestreamDbSizeRequest {
1072 2 : latest: true,
1073 2 : lsn: Lsn(4),
1074 2 : dbnode: 7,
1075 2 : }),
1076 2 : ];
1077 10 : for msg in messages {
1078 8 : let bytes = msg.serialize();
1079 8 : let reconstructed = PagestreamFeMessage::parse(&mut bytes.reader()).unwrap();
1080 8 : assert!(msg == reconstructed);
1081 : }
1082 2 : }
1083 :
1084 2 : #[test]
1085 2 : fn test_tenantinfo_serde() {
1086 2 : // Test serialization/deserialization of TenantInfo
1087 2 : let original_active = TenantInfo {
1088 2 : id: TenantShardId::unsharded(TenantId::generate()),
1089 2 : state: TenantState::Active,
1090 2 : current_physical_size: Some(42),
1091 2 : attachment_status: TenantAttachmentStatus::Attached,
1092 2 : generation: None,
1093 2 : };
1094 2 : let expected_active = json!({
1095 2 : "id": original_active.id.to_string(),
1096 2 : "state": {
1097 2 : "slug": "Active",
1098 2 : },
1099 2 : "current_physical_size": 42,
1100 2 : "attachment_status": {
1101 2 : "slug":"attached",
1102 2 : }
1103 2 : });
1104 2 :
1105 2 : let original_broken = TenantInfo {
1106 2 : id: TenantShardId::unsharded(TenantId::generate()),
1107 2 : state: TenantState::Broken {
1108 2 : reason: "reason".into(),
1109 2 : backtrace: "backtrace info".into(),
1110 2 : },
1111 2 : current_physical_size: Some(42),
1112 2 : attachment_status: TenantAttachmentStatus::Attached,
1113 2 : generation: None,
1114 2 : };
1115 2 : let expected_broken = json!({
1116 2 : "id": original_broken.id.to_string(),
1117 2 : "state": {
1118 2 : "slug": "Broken",
1119 2 : "data": {
1120 2 : "backtrace": "backtrace info",
1121 2 : "reason": "reason",
1122 2 : }
1123 2 : },
1124 2 : "current_physical_size": 42,
1125 2 : "attachment_status": {
1126 2 : "slug":"attached",
1127 2 : }
1128 2 : });
1129 2 :
1130 2 : assert_eq!(
1131 2 : serde_json::to_value(&original_active).unwrap(),
1132 2 : expected_active
1133 2 : );
1134 :
1135 2 : assert_eq!(
1136 2 : serde_json::to_value(&original_broken).unwrap(),
1137 2 : expected_broken
1138 2 : );
1139 2 : assert!(format!("{:?}", &original_broken.state).contains("reason"));
1140 2 : assert!(format!("{:?}", &original_broken.state).contains("backtrace info"));
1141 2 : }
1142 :
1143 2 : #[test]
1144 2 : fn test_reject_unknown_field() {
1145 2 : let id = TenantId::generate();
1146 2 : let create_request = json!({
1147 2 : "new_tenant_id": id.to_string(),
1148 2 : "unknown_field": "unknown_value".to_string(),
1149 2 : });
1150 2 : let err = serde_json::from_value::<TenantCreateRequest>(create_request).unwrap_err();
1151 2 : assert!(
1152 2 : err.to_string().contains("unknown field `unknown_field`"),
1153 0 : "expect unknown field `unknown_field` error, got: {}",
1154 : err
1155 : );
1156 :
1157 2 : let id = TenantId::generate();
1158 2 : let config_request = json!({
1159 2 : "tenant_id": id.to_string(),
1160 2 : "unknown_field": "unknown_value".to_string(),
1161 2 : });
1162 2 : let err = serde_json::from_value::<TenantConfigRequest>(config_request).unwrap_err();
1163 2 : assert!(
1164 2 : err.to_string().contains("unknown field `unknown_field`"),
1165 0 : "expect unknown field `unknown_field` error, got: {}",
1166 : err
1167 : );
1168 :
1169 2 : let attach_request = json!({
1170 2 : "config": {
1171 2 : "unknown_field": "unknown_value".to_string(),
1172 2 : },
1173 2 : });
1174 2 : let err = serde_json::from_value::<TenantAttachRequest>(attach_request).unwrap_err();
1175 2 : assert!(
1176 2 : err.to_string().contains("unknown field `unknown_field`"),
1177 0 : "expect unknown field `unknown_field` error, got: {}",
1178 : err
1179 : );
1180 2 : }
1181 :
1182 2 : #[test]
1183 2 : fn tenantstatus_activating_serde() {
1184 2 : let states = [
1185 2 : TenantState::Activating(ActivatingFrom::Loading),
1186 2 : TenantState::Activating(ActivatingFrom::Attaching),
1187 2 : ];
1188 2 : let expected = "[{\"slug\":\"Activating\",\"data\":\"Loading\"},{\"slug\":\"Activating\",\"data\":\"Attaching\"}]";
1189 2 :
1190 2 : let actual = serde_json::to_string(&states).unwrap();
1191 2 :
1192 2 : assert_eq!(actual, expected);
1193 :
1194 2 : let parsed = serde_json::from_str::<Vec<TenantState>>(&actual).unwrap();
1195 2 :
1196 2 : assert_eq!(states.as_slice(), &parsed);
1197 2 : }
1198 :
1199 2 : #[test]
1200 2 : fn tenantstatus_activating_strum() {
1201 2 : // tests added, because we use these for metrics
1202 2 : let examples = [
1203 2 : (line!(), TenantState::Loading, "Loading"),
1204 2 : (line!(), TenantState::Attaching, "Attaching"),
1205 2 : (
1206 2 : line!(),
1207 2 : TenantState::Activating(ActivatingFrom::Loading),
1208 2 : "Activating",
1209 2 : ),
1210 2 : (
1211 2 : line!(),
1212 2 : TenantState::Activating(ActivatingFrom::Attaching),
1213 2 : "Activating",
1214 2 : ),
1215 2 : (line!(), TenantState::Active, "Active"),
1216 2 : (
1217 2 : line!(),
1218 2 : TenantState::Stopping {
1219 2 : progress: utils::completion::Barrier::default(),
1220 2 : },
1221 2 : "Stopping",
1222 2 : ),
1223 2 : (
1224 2 : line!(),
1225 2 : TenantState::Broken {
1226 2 : reason: "Example".into(),
1227 2 : backtrace: "Looooong backtrace".into(),
1228 2 : },
1229 2 : "Broken",
1230 2 : ),
1231 2 : ];
1232 :
1233 16 : for (line, rendered, expected) in examples {
1234 14 : let actual: &'static str = rendered.into();
1235 14 : assert_eq!(actual, expected, "example on {line}");
1236 : }
1237 2 : }
1238 : }
|
