Line data Source code
1 : use camino::Utf8PathBuf;
2 :
3 : #[cfg(test)]
4 : mod tests;
5 :
6 : use const_format::formatcp;
7 : pub const DEFAULT_PG_LISTEN_PORT: u16 = 64000;
8 : pub const DEFAULT_PG_LISTEN_ADDR: &str = formatcp!("127.0.0.1:{DEFAULT_PG_LISTEN_PORT}");
9 : pub const DEFAULT_HTTP_LISTEN_PORT: u16 = 9898;
10 : pub const DEFAULT_HTTP_LISTEN_ADDR: &str = formatcp!("127.0.0.1:{DEFAULT_HTTP_LISTEN_PORT}");
11 :
12 : use postgres_backend::AuthType;
13 : use remote_storage::RemoteStorageConfig;
14 : use serde_with::serde_as;
15 : use std::{
16 : collections::HashMap,
17 : num::{NonZeroU64, NonZeroUsize},
18 : str::FromStr,
19 : time::Duration,
20 : };
21 : use utils::{logging::LogFormat, postgres_client::PostgresClientProtocol};
22 :
23 : use crate::models::ImageCompressionAlgorithm;
24 : use crate::models::LsnLease;
25 :
26 : // Certain metadata (e.g. externally-addressable name, AZ) is delivered
27 : // as a separate structure. This information is not neeed by the pageserver
28 : // itself, it is only used for registering the pageserver with the control
29 : // plane and/or storage controller.
30 : //
31 5 : #[derive(PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
32 : pub struct NodeMetadata {
33 : #[serde(rename = "host")]
34 : pub postgres_host: String,
35 : #[serde(rename = "port")]
36 : pub postgres_port: u16,
37 : pub http_host: String,
38 : pub http_port: u16,
39 :
40 : // Deployment tools may write fields to the metadata file beyond what we
41 : // use in this type: this type intentionally only names fields that require.
42 : #[serde(flatten)]
43 : pub other: HashMap<String, serde_json::Value>,
44 : }
45 :
46 : /// `pageserver.toml`
47 : ///
48 : /// We use serde derive with `#[serde(default)]` to generate a deserializer
49 : /// that fills in the default values for each config field.
50 : ///
51 : /// If there cannot be a static default value because we need to make runtime
52 : /// checks to determine the default, make it an `Option` (which defaults to None).
53 : /// The runtime check should be done in the consuming crate, i.e., `pageserver`.
54 : #[serde_as]
55 22 : #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
56 : #[serde(default, deny_unknown_fields)]
57 : pub struct ConfigToml {
58 : // types mapped 1:1 into the runtime PageServerConfig type
59 : pub listen_pg_addr: String,
60 : pub listen_http_addr: String,
61 : pub availability_zone: Option<String>,
62 : #[serde(with = "humantime_serde")]
63 : pub wait_lsn_timeout: Duration,
64 : #[serde(with = "humantime_serde")]
65 : pub wal_redo_timeout: Duration,
66 : pub superuser: String,
67 : pub locale: String,
68 : pub page_cache_size: usize,
69 : pub max_file_descriptors: usize,
70 : pub pg_distrib_dir: Option<Utf8PathBuf>,
71 : #[serde_as(as = "serde_with::DisplayFromStr")]
72 : pub http_auth_type: AuthType,
73 : #[serde_as(as = "serde_with::DisplayFromStr")]
74 : pub pg_auth_type: AuthType,
75 : pub auth_validation_public_key_path: Option<Utf8PathBuf>,
76 : pub remote_storage: Option<RemoteStorageConfig>,
77 : pub tenant_config: TenantConfigToml,
78 : #[serde_as(as = "serde_with::DisplayFromStr")]
79 : pub broker_endpoint: storage_broker::Uri,
80 : #[serde(with = "humantime_serde")]
81 : pub broker_keepalive_interval: Duration,
82 : #[serde_as(as = "serde_with::DisplayFromStr")]
83 : pub log_format: LogFormat,
84 : pub concurrent_tenant_warmup: NonZeroUsize,
85 : pub concurrent_tenant_size_logical_size_queries: NonZeroUsize,
86 : #[serde(with = "humantime_serde")]
87 : pub metric_collection_interval: Duration,
88 : pub metric_collection_endpoint: Option<reqwest::Url>,
89 : pub metric_collection_bucket: Option<RemoteStorageConfig>,
90 : #[serde(with = "humantime_serde")]
91 : pub synthetic_size_calculation_interval: Duration,
92 : pub disk_usage_based_eviction: Option<DiskUsageEvictionTaskConfig>,
93 : pub test_remote_failures: u64,
94 : pub ondemand_download_behavior_treat_error_as_warn: bool,
95 : #[serde(with = "humantime_serde")]
96 : pub background_task_maximum_delay: Duration,
97 : pub control_plane_api: Option<reqwest::Url>,
98 : pub control_plane_api_token: Option<String>,
99 : pub control_plane_emergency_mode: bool,
100 : pub heatmap_upload_concurrency: usize,
101 : pub secondary_download_concurrency: usize,
102 : pub virtual_file_io_engine: Option<crate::models::virtual_file::IoEngineKind>,
103 : pub ingest_batch_size: u64,
104 : pub max_vectored_read_bytes: MaxVectoredReadBytes,
105 : pub image_compression: ImageCompressionAlgorithm,
106 : pub timeline_offloading: bool,
107 : pub ephemeral_bytes_per_memory_kb: usize,
108 : pub l0_flush: Option<crate::models::L0FlushConfig>,
109 : pub virtual_file_io_mode: Option<crate::models::virtual_file::IoMode>,
110 : #[serde(skip_serializing_if = "Option::is_none")]
111 : pub no_sync: Option<bool>,
112 : #[serde(with = "humantime_serde")]
113 : pub server_side_batch_timeout: Option<Duration>,
114 : pub wal_receiver_protocol: PostgresClientProtocol,
115 : }
116 :
117 4 : #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
118 : #[serde(deny_unknown_fields)]
119 : pub struct DiskUsageEvictionTaskConfig {
120 : pub max_usage_pct: utils::serde_percent::Percent,
121 : pub min_avail_bytes: u64,
122 : #[serde(with = "humantime_serde")]
123 : pub period: Duration,
124 : #[cfg(feature = "testing")]
125 : pub mock_statvfs: Option<statvfs::mock::Behavior>,
126 : /// Select sorting for evicted layers
127 : #[serde(default)]
128 : pub eviction_order: EvictionOrder,
129 : }
130 :
131 : pub mod statvfs {
132 : pub mod mock {
133 0 : #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
134 : #[serde(tag = "type")]
135 : pub enum Behavior {
136 : Success {
137 : blocksize: u64,
138 : total_blocks: u64,
139 : name_filter: Option<utils::serde_regex::Regex>,
140 : },
141 : #[cfg(feature = "testing")]
142 : Failure { mocked_error: MockedError },
143 : }
144 :
145 : #[cfg(feature = "testing")]
146 0 : #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
147 : #[allow(clippy::upper_case_acronyms)]
148 : pub enum MockedError {
149 : EIO,
150 : }
151 :
152 : #[cfg(feature = "testing")]
153 : impl From<MockedError> for nix::Error {
154 0 : fn from(e: MockedError) -> Self {
155 0 : match e {
156 0 : MockedError::EIO => nix::Error::EIO,
157 0 : }
158 0 : }
159 : }
160 : }
161 : }
162 :
163 0 : #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
164 : #[serde(tag = "type", content = "args")]
165 : pub enum EvictionOrder {
166 : RelativeAccessed {
167 : highest_layer_count_loses_first: bool,
168 : },
169 : }
170 :
171 : impl Default for EvictionOrder {
172 2 : fn default() -> Self {
173 2 : Self::RelativeAccessed {
174 2 : highest_layer_count_loses_first: true,
175 2 : }
176 2 : }
177 : }
178 :
179 0 : #[derive(Copy, Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
180 : #[serde(transparent)]
181 : pub struct MaxVectoredReadBytes(pub NonZeroUsize);
182 :
183 : /// A tenant's calcuated configuration, which is the result of merging a
184 : /// tenant's TenantConfOpt with the global TenantConf from PageServerConf.
185 : ///
186 : /// For storing and transmitting individual tenant's configuration, see
187 : /// TenantConfOpt.
188 4 : #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
189 : #[serde(deny_unknown_fields, default)]
190 : pub struct TenantConfigToml {
191 : // Flush out an inmemory layer, if it's holding WAL older than this
192 : // This puts a backstop on how much WAL needs to be re-digested if the
193 : // page server crashes.
194 : // This parameter actually determines L0 layer file size.
195 : pub checkpoint_distance: u64,
196 : // Inmemory layer is also flushed at least once in checkpoint_timeout to
197 : // eventually upload WAL after activity is stopped.
198 : #[serde(with = "humantime_serde")]
199 : pub checkpoint_timeout: Duration,
200 : // Target file size, when creating image and delta layers.
201 : // This parameter determines L1 layer file size.
202 : pub compaction_target_size: u64,
203 : // How often to check if there's compaction work to be done.
204 : // Duration::ZERO means automatic compaction is disabled.
205 : #[serde(with = "humantime_serde")]
206 : pub compaction_period: Duration,
207 : // Level0 delta layer threshold for compaction.
208 : pub compaction_threshold: usize,
209 : pub compaction_algorithm: crate::models::CompactionAlgorithmSettings,
210 : // Determines how much history is retained, to allow
211 : // branching and read replicas at an older point in time.
212 : // The unit is #of bytes of WAL.
213 : // Page versions older than this are garbage collected away.
214 : pub gc_horizon: u64,
215 : // Interval at which garbage collection is triggered.
216 : // Duration::ZERO means automatic GC is disabled
217 : #[serde(with = "humantime_serde")]
218 : pub gc_period: Duration,
219 : // Delta layer churn threshold to create L1 image layers.
220 : pub image_creation_threshold: usize,
221 : // Determines how much history is retained, to allow
222 : // branching and read replicas at an older point in time.
223 : // The unit is time.
224 : // Page versions older than this are garbage collected away.
225 : #[serde(with = "humantime_serde")]
226 : pub pitr_interval: Duration,
227 : /// Maximum amount of time to wait while opening a connection to receive wal, before erroring.
228 : #[serde(with = "humantime_serde")]
229 : pub walreceiver_connect_timeout: Duration,
230 : /// Considers safekeepers stalled after no WAL updates were received longer than this threshold.
231 : /// A stalled safekeeper will be changed to a newer one when it appears.
232 : #[serde(with = "humantime_serde")]
233 : pub lagging_wal_timeout: Duration,
234 : /// Considers safekeepers lagging when their WAL is behind another safekeeper for more than this threshold.
235 : /// A lagging safekeeper will be changed after `lagging_wal_timeout` time elapses since the last WAL update,
236 : /// to avoid eager reconnects.
237 : pub max_lsn_wal_lag: NonZeroU64,
238 : pub eviction_policy: crate::models::EvictionPolicy,
239 : pub min_resident_size_override: Option<u64>,
240 : // See the corresponding metric's help string.
241 : #[serde(with = "humantime_serde")]
242 : pub evictions_low_residence_duration_metric_threshold: Duration,
243 :
244 : /// If non-zero, the period between uploads of a heatmap from attached tenants. This
245 : /// may be disabled if a Tenant will not have secondary locations: only secondary
246 : /// locations will use the heatmap uploaded by attached locations.
247 : #[serde(with = "humantime_serde")]
248 : pub heatmap_period: Duration,
249 :
250 : /// If true then SLRU segments are dowloaded on demand, if false SLRU segments are included in basebackup
251 : pub lazy_slru_download: bool,
252 :
253 : pub timeline_get_throttle: crate::models::ThrottleConfig,
254 :
255 : // How much WAL must be ingested before checking again whether a new image layer is required.
256 : // Expresed in multiples of checkpoint distance.
257 : pub image_layer_creation_check_threshold: u8,
258 :
259 : /// The length for an explicit LSN lease request.
260 : /// Layers needed to reconstruct pages at LSN will not be GC-ed during this interval.
261 : #[serde(with = "humantime_serde")]
262 : pub lsn_lease_length: Duration,
263 :
264 : /// The length for an implicit LSN lease granted as part of `get_lsn_by_timestamp` request.
265 : /// Layers needed to reconstruct pages at LSN will not be GC-ed during this interval.
266 : #[serde(with = "humantime_serde")]
267 : pub lsn_lease_length_for_ts: Duration,
268 :
269 : /// Enable auto-offloading of timelines.
270 : /// (either this flag or the pageserver-global one need to be set)
271 : pub timeline_offloading: bool,
272 : }
273 :
274 : pub mod defaults {
275 : use crate::models::ImageCompressionAlgorithm;
276 :
277 : pub use storage_broker::DEFAULT_ENDPOINT as BROKER_DEFAULT_ENDPOINT;
278 : use utils::postgres_client;
279 :
280 : pub const DEFAULT_WAIT_LSN_TIMEOUT: &str = "300 s";
281 : pub const DEFAULT_WAL_REDO_TIMEOUT: &str = "60 s";
282 :
283 : pub const DEFAULT_SUPERUSER: &str = "cloud_admin";
284 : pub const DEFAULT_LOCALE: &str = if cfg!(target_os = "macos") {
285 : "C"
286 : } else {
287 : "C.UTF-8"
288 : };
289 :
290 : pub const DEFAULT_PAGE_CACHE_SIZE: usize = 8192;
291 : pub const DEFAULT_MAX_FILE_DESCRIPTORS: usize = 100;
292 :
293 : pub const DEFAULT_LOG_FORMAT: &str = "plain";
294 :
295 : pub const DEFAULT_CONCURRENT_TENANT_WARMUP: usize = 8;
296 :
297 : pub const DEFAULT_CONCURRENT_TENANT_SIZE_LOGICAL_SIZE_QUERIES: usize = 1;
298 :
299 : pub const DEFAULT_METRIC_COLLECTION_INTERVAL: &str = "10 min";
300 : pub const DEFAULT_METRIC_COLLECTION_ENDPOINT: Option<reqwest::Url> = None;
301 : pub const DEFAULT_SYNTHETIC_SIZE_CALCULATION_INTERVAL: &str = "10 min";
302 : pub const DEFAULT_BACKGROUND_TASK_MAXIMUM_DELAY: &str = "10s";
303 :
304 : pub const DEFAULT_HEATMAP_UPLOAD_CONCURRENCY: usize = 8;
305 : pub const DEFAULT_SECONDARY_DOWNLOAD_CONCURRENCY: usize = 1;
306 :
307 : pub const DEFAULT_INGEST_BATCH_SIZE: u64 = 100;
308 :
309 : /// Soft limit for the maximum size of a vectored read.
310 : ///
311 : /// This is determined by the largest NeonWalRecord that can exist (minus dbdir and reldir keys
312 : /// which are bounded by the blob io limits only). As of this writing, that is a `NeonWalRecord::ClogSetCommitted` record,
313 : /// with 32k xids. That's the max number of XIDS on a single CLOG page. The size of such a record
314 : /// is `sizeof(Transactionid) * 32768 + (some fixed overhead from 'timestamp`, the Vec length and whatever extra serde serialization adds)`.
315 : /// That is, slightly above 128 kB.
316 : pub const DEFAULT_MAX_VECTORED_READ_BYTES: usize = 130 * 1024; // 130 KiB
317 :
318 : pub const DEFAULT_IMAGE_COMPRESSION: ImageCompressionAlgorithm =
319 : ImageCompressionAlgorithm::Zstd { level: Some(1) };
320 :
321 : pub const DEFAULT_EPHEMERAL_BYTES_PER_MEMORY_KB: usize = 0;
322 :
323 : pub const DEFAULT_IO_BUFFER_ALIGNMENT: usize = 512;
324 :
325 : pub const DEFAULT_SERVER_SIDE_BATCH_TIMEOUT: Option<&str> = None;
326 :
327 : pub const DEFAULT_WAL_RECEIVER_PROTOCOL: utils::postgres_client::PostgresClientProtocol =
328 : utils::postgres_client::PostgresClientProtocol::Interpreted {
329 : format: utils::postgres_client::InterpretedFormat::Protobuf,
330 : compression: Some(utils::postgres_client::Compression::Zstd { level: 1 }),
331 : };
332 : }
333 :
334 : impl Default for ConfigToml {
335 210 : fn default() -> Self {
336 : use defaults::*;
337 :
338 210 : Self {
339 210 : listen_pg_addr: (DEFAULT_PG_LISTEN_ADDR.to_string()),
340 210 : listen_http_addr: (DEFAULT_HTTP_LISTEN_ADDR.to_string()),
341 210 : availability_zone: (None),
342 210 : wait_lsn_timeout: (humantime::parse_duration(DEFAULT_WAIT_LSN_TIMEOUT)
343 210 : .expect("cannot parse default wait lsn timeout")),
344 210 : wal_redo_timeout: (humantime::parse_duration(DEFAULT_WAL_REDO_TIMEOUT)
345 210 : .expect("cannot parse default wal redo timeout")),
346 210 : superuser: (DEFAULT_SUPERUSER.to_string()),
347 210 : locale: DEFAULT_LOCALE.to_string(),
348 210 : page_cache_size: (DEFAULT_PAGE_CACHE_SIZE),
349 210 : max_file_descriptors: (DEFAULT_MAX_FILE_DESCRIPTORS),
350 210 : pg_distrib_dir: None, // Utf8PathBuf::from("./pg_install"), // TODO: formely, this was std::env::current_dir()
351 210 : http_auth_type: (AuthType::Trust),
352 210 : pg_auth_type: (AuthType::Trust),
353 210 : auth_validation_public_key_path: (None),
354 210 : remote_storage: None,
355 210 : broker_endpoint: (storage_broker::DEFAULT_ENDPOINT
356 210 : .parse()
357 210 : .expect("failed to parse default broker endpoint")),
358 210 : broker_keepalive_interval: (humantime::parse_duration(
359 210 : storage_broker::DEFAULT_KEEPALIVE_INTERVAL,
360 210 : )
361 210 : .expect("cannot parse default keepalive interval")),
362 210 : log_format: (LogFormat::from_str(DEFAULT_LOG_FORMAT).unwrap()),
363 210 :
364 210 : concurrent_tenant_warmup: (NonZeroUsize::new(DEFAULT_CONCURRENT_TENANT_WARMUP)
365 210 : .expect("Invalid default constant")),
366 210 : concurrent_tenant_size_logical_size_queries: NonZeroUsize::new(
367 210 : DEFAULT_CONCURRENT_TENANT_SIZE_LOGICAL_SIZE_QUERIES,
368 210 : )
369 210 : .unwrap(),
370 210 : metric_collection_interval: (humantime::parse_duration(
371 210 : DEFAULT_METRIC_COLLECTION_INTERVAL,
372 210 : )
373 210 : .expect("cannot parse default metric collection interval")),
374 210 : synthetic_size_calculation_interval: (humantime::parse_duration(
375 210 : DEFAULT_SYNTHETIC_SIZE_CALCULATION_INTERVAL,
376 210 : )
377 210 : .expect("cannot parse default synthetic size calculation interval")),
378 210 : metric_collection_endpoint: (DEFAULT_METRIC_COLLECTION_ENDPOINT),
379 210 :
380 210 : metric_collection_bucket: (None),
381 210 :
382 210 : disk_usage_based_eviction: (None),
383 210 :
384 210 : test_remote_failures: (0),
385 210 :
386 210 : ondemand_download_behavior_treat_error_as_warn: (false),
387 210 :
388 210 : background_task_maximum_delay: (humantime::parse_duration(
389 210 : DEFAULT_BACKGROUND_TASK_MAXIMUM_DELAY,
390 210 : )
391 210 : .unwrap()),
392 210 :
393 210 : control_plane_api: (None),
394 210 : control_plane_api_token: (None),
395 210 : control_plane_emergency_mode: (false),
396 210 :
397 210 : heatmap_upload_concurrency: (DEFAULT_HEATMAP_UPLOAD_CONCURRENCY),
398 210 : secondary_download_concurrency: (DEFAULT_SECONDARY_DOWNLOAD_CONCURRENCY),
399 210 :
400 210 : ingest_batch_size: (DEFAULT_INGEST_BATCH_SIZE),
401 210 :
402 210 : virtual_file_io_engine: None,
403 210 :
404 210 : max_vectored_read_bytes: (MaxVectoredReadBytes(
405 210 : NonZeroUsize::new(DEFAULT_MAX_VECTORED_READ_BYTES).unwrap(),
406 210 : )),
407 210 : image_compression: (DEFAULT_IMAGE_COMPRESSION),
408 210 : timeline_offloading: false,
409 210 : ephemeral_bytes_per_memory_kb: (DEFAULT_EPHEMERAL_BYTES_PER_MEMORY_KB),
410 210 : l0_flush: None,
411 210 : virtual_file_io_mode: None,
412 210 : server_side_batch_timeout: DEFAULT_SERVER_SIDE_BATCH_TIMEOUT
413 210 : .map(|duration| humantime::parse_duration(duration).unwrap()),
414 210 : tenant_config: TenantConfigToml::default(),
415 210 : no_sync: None,
416 210 : wal_receiver_protocol: DEFAULT_WAL_RECEIVER_PROTOCOL,
417 210 : }
418 210 : }
419 : }
420 :
421 : pub mod tenant_conf_defaults {
422 :
423 : // FIXME: This current value is very low. I would imagine something like 1 GB or 10 GB
424 : // would be more appropriate. But a low value forces the code to be exercised more,
425 : // which is good for now to trigger bugs.
426 : // This parameter actually determines L0 layer file size.
427 : pub const DEFAULT_CHECKPOINT_DISTANCE: u64 = 256 * 1024 * 1024;
428 : pub const DEFAULT_CHECKPOINT_TIMEOUT: &str = "10 m";
429 :
430 : // FIXME the below configs are only used by legacy algorithm. The new algorithm
431 : // has different parameters.
432 :
433 : // Target file size, when creating image and delta layers.
434 : // This parameter determines L1 layer file size.
435 : pub const DEFAULT_COMPACTION_TARGET_SIZE: u64 = 128 * 1024 * 1024;
436 :
437 : pub const DEFAULT_COMPACTION_PERIOD: &str = "20 s";
438 : pub const DEFAULT_COMPACTION_THRESHOLD: usize = 10;
439 : pub const DEFAULT_COMPACTION_ALGORITHM: crate::models::CompactionAlgorithm =
440 : crate::models::CompactionAlgorithm::Legacy;
441 :
442 : pub const DEFAULT_GC_HORIZON: u64 = 64 * 1024 * 1024;
443 :
444 : // Large DEFAULT_GC_PERIOD is fine as long as PITR_INTERVAL is larger.
445 : // If there's a need to decrease this value, first make sure that GC
446 : // doesn't hold a layer map write lock for non-trivial operations.
447 : // Relevant: https://github.com/neondatabase/neon/issues/3394
448 : pub const DEFAULT_GC_PERIOD: &str = "1 hr";
449 : pub const DEFAULT_IMAGE_CREATION_THRESHOLD: usize = 3;
450 : pub const DEFAULT_PITR_INTERVAL: &str = "7 days";
451 : pub const DEFAULT_WALRECEIVER_CONNECT_TIMEOUT: &str = "10 seconds";
452 : pub const DEFAULT_WALRECEIVER_LAGGING_WAL_TIMEOUT: &str = "10 seconds";
453 : // The default limit on WAL lag should be set to avoid causing disconnects under high throughput
454 : // scenarios: since the broker stats are updated ~1/s, a value of 1GiB should be sufficient for
455 : // throughputs up to 1GiB/s per timeline.
456 : pub const DEFAULT_MAX_WALRECEIVER_LSN_WAL_LAG: u64 = 1024 * 1024 * 1024;
457 : pub const DEFAULT_EVICTIONS_LOW_RESIDENCE_DURATION_METRIC_THRESHOLD: &str = "24 hour";
458 : // By default ingest enough WAL for two new L0 layers before checking if new image
459 : // image layers should be created.
460 : pub const DEFAULT_IMAGE_LAYER_CREATION_CHECK_THRESHOLD: u8 = 2;
461 : }
462 :
463 : impl Default for TenantConfigToml {
464 394 : fn default() -> Self {
465 : use tenant_conf_defaults::*;
466 394 : Self {
467 394 : checkpoint_distance: DEFAULT_CHECKPOINT_DISTANCE,
468 394 : checkpoint_timeout: humantime::parse_duration(DEFAULT_CHECKPOINT_TIMEOUT)
469 394 : .expect("cannot parse default checkpoint timeout"),
470 394 : compaction_target_size: DEFAULT_COMPACTION_TARGET_SIZE,
471 394 : compaction_period: humantime::parse_duration(DEFAULT_COMPACTION_PERIOD)
472 394 : .expect("cannot parse default compaction period"),
473 394 : compaction_threshold: DEFAULT_COMPACTION_THRESHOLD,
474 394 : compaction_algorithm: crate::models::CompactionAlgorithmSettings {
475 394 : kind: DEFAULT_COMPACTION_ALGORITHM,
476 394 : },
477 394 : gc_horizon: DEFAULT_GC_HORIZON,
478 394 : gc_period: humantime::parse_duration(DEFAULT_GC_PERIOD)
479 394 : .expect("cannot parse default gc period"),
480 394 : image_creation_threshold: DEFAULT_IMAGE_CREATION_THRESHOLD,
481 394 : pitr_interval: humantime::parse_duration(DEFAULT_PITR_INTERVAL)
482 394 : .expect("cannot parse default PITR interval"),
483 394 : walreceiver_connect_timeout: humantime::parse_duration(
484 394 : DEFAULT_WALRECEIVER_CONNECT_TIMEOUT,
485 394 : )
486 394 : .expect("cannot parse default walreceiver connect timeout"),
487 394 : lagging_wal_timeout: humantime::parse_duration(DEFAULT_WALRECEIVER_LAGGING_WAL_TIMEOUT)
488 394 : .expect("cannot parse default walreceiver lagging wal timeout"),
489 394 : max_lsn_wal_lag: NonZeroU64::new(DEFAULT_MAX_WALRECEIVER_LSN_WAL_LAG)
490 394 : .expect("cannot parse default max walreceiver Lsn wal lag"),
491 394 : eviction_policy: crate::models::EvictionPolicy::NoEviction,
492 394 : min_resident_size_override: None,
493 394 : evictions_low_residence_duration_metric_threshold: humantime::parse_duration(
494 394 : DEFAULT_EVICTIONS_LOW_RESIDENCE_DURATION_METRIC_THRESHOLD,
495 394 : )
496 394 : .expect("cannot parse default evictions_low_residence_duration_metric_threshold"),
497 394 : heatmap_period: Duration::ZERO,
498 394 : lazy_slru_download: false,
499 394 : timeline_get_throttle: crate::models::ThrottleConfig::disabled(),
500 394 : image_layer_creation_check_threshold: DEFAULT_IMAGE_LAYER_CREATION_CHECK_THRESHOLD,
501 394 : lsn_lease_length: LsnLease::DEFAULT_LENGTH,
502 394 : lsn_lease_length_for_ts: LsnLease::DEFAULT_LENGTH_FOR_TS,
503 394 : timeline_offloading: false,
504 394 : }
505 394 : }
506 : }
|
