Line data Source code
1 : //! Functions for handling page server configuration options
2 : //!
3 : //! Configuration options can be set in the pageserver.toml configuration
4 : //! file, or on the command line.
5 : //! See also `settings.md` for better description on every parameter.
6 :
7 : use std::env;
8 : use std::num::NonZeroUsize;
9 : use std::sync::Arc;
10 : use std::time::Duration;
11 :
12 : use anyhow::{Context, bail, ensure};
13 : use camino::{Utf8Path, Utf8PathBuf};
14 : use once_cell::sync::OnceCell;
15 : use pageserver_api::config::{DiskUsageEvictionTaskConfig, MaxVectoredReadBytes};
16 : use pageserver_api::models::ImageCompressionAlgorithm;
17 : use pageserver_api::shard::TenantShardId;
18 : use postgres_backend::AuthType;
19 : use remote_storage::{RemotePath, RemoteStorageConfig};
20 : use reqwest::{Certificate, Url};
21 : use storage_broker::Uri;
22 : use utils::id::{NodeId, TimelineId};
23 : use utils::logging::{LogFormat, SecretString};
24 : use utils::postgres_client::PostgresClientProtocol;
25 :
26 : use crate::tenant::storage_layer::inmemory_layer::IndexEntry;
27 : use crate::tenant::{TENANTS_SEGMENT_NAME, TIMELINES_SEGMENT_NAME};
28 : use crate::virtual_file::io_engine;
29 : use crate::{TENANT_HEATMAP_BASENAME, TENANT_LOCATION_CONFIG_NAME, virtual_file};
30 :
31 : /// Global state of pageserver.
32 : ///
33 : /// It's mostly immutable configuration, but some semaphores and the
34 : /// like crept in over time and the name stuck.
35 : ///
36 : /// Instantiated by deserializing `pageserver.toml` into [`pageserver_api::config::ConfigToml`]
37 : /// and passing that to [`PageServerConf::parse_and_validate`].
38 : ///
39 : /// # Adding a New Field
40 : ///
41 : /// 1. Add the field to `pageserver_api::config::ConfigToml`.
42 : /// 2. Fix compiler errors (exhaustive destructuring will guide you).
43 : ///
44 : /// For fields that require additional validation or filling in of defaults at runtime,
45 : /// check for examples in the [`PageServerConf::parse_and_validate`] method.
46 : #[derive(Debug, Clone)]
47 : pub struct PageServerConf {
48 : // Identifier of that particular pageserver so e g safekeepers
49 : // can safely distinguish different pageservers
50 : pub id: NodeId,
51 :
52 : /// Example (default): 127.0.0.1:64000
53 : pub listen_pg_addr: String,
54 : /// Example (default): 127.0.0.1:9898
55 : pub listen_http_addr: String,
56 : /// Example: 127.0.0.1:9899
57 : pub listen_https_addr: Option<String>,
58 :
59 : /// Path to a file with certificate's private key for https API.
60 : /// Default: server.key
61 : pub ssl_key_file: Utf8PathBuf,
62 : /// Path to a file with a X509 certificate for https API.
63 : /// Default: server.crt
64 : pub ssl_cert_file: Utf8PathBuf,
65 : /// Period to reload certificate and private key from files.
66 : /// Default: 60s.
67 : pub ssl_cert_reload_period: Duration,
68 : /// Trusted root CA certificates to use in https APIs.
69 : pub ssl_ca_certs: Vec<Certificate>,
70 :
71 : /// Current availability zone. Used for traffic metrics.
72 : pub availability_zone: Option<String>,
73 :
74 : // Timeout when waiting for WAL receiver to catch up to an LSN given in a GetPage@LSN call.
75 : pub wait_lsn_timeout: Duration,
76 : // How long to wait for WAL redo to complete.
77 : pub wal_redo_timeout: Duration,
78 :
79 : pub superuser: String,
80 : pub locale: String,
81 :
82 : pub page_cache_size: usize,
83 : pub max_file_descriptors: usize,
84 :
85 : // Repository directory, relative to current working directory.
86 : // Normally, the page server changes the current working directory
87 : // to the repository, and 'workdir' is always '.'. But we don't do
88 : // that during unit testing, because the current directory is global
89 : // to the process but different unit tests work on different
90 : // repositories.
91 : pub workdir: Utf8PathBuf,
92 :
93 : pub pg_distrib_dir: Utf8PathBuf,
94 :
95 : // Authentication
96 : /// authentication method for the HTTP mgmt API
97 : pub http_auth_type: AuthType,
98 : /// authentication method for libpq connections from compute
99 : pub pg_auth_type: AuthType,
100 : /// Path to a file or directory containing public key(s) for verifying JWT tokens.
101 : /// Used for both mgmt and compute auth, if enabled.
102 : pub auth_validation_public_key_path: Option<Utf8PathBuf>,
103 :
104 : pub remote_storage_config: Option<RemoteStorageConfig>,
105 :
106 : pub default_tenant_conf: pageserver_api::config::TenantConfigToml,
107 :
108 : /// Storage broker endpoints to connect to.
109 : pub broker_endpoint: Uri,
110 : pub broker_keepalive_interval: Duration,
111 :
112 : pub log_format: LogFormat,
113 :
114 : /// Number of tenants which will be concurrently loaded from remote storage proactively on startup or attach.
115 : ///
116 : /// A lower value implicitly deprioritizes loading such tenants, vs. other work in the system.
117 : pub concurrent_tenant_warmup: ConfigurableSemaphore,
118 :
119 : /// Number of concurrent [`Tenant::gather_size_inputs`](crate::tenant::Tenant::gather_size_inputs) allowed.
120 : pub concurrent_tenant_size_logical_size_queries: ConfigurableSemaphore,
121 : /// Limit of concurrent [`Tenant::gather_size_inputs`] issued by module `eviction_task`.
122 : /// The number of permits is the same as `concurrent_tenant_size_logical_size_queries`.
123 : /// See the comment in `eviction_task` for details.
124 : ///
125 : /// [`Tenant::gather_size_inputs`]: crate::tenant::Tenant::gather_size_inputs
126 : pub eviction_task_immitated_concurrent_logical_size_queries: ConfigurableSemaphore,
127 :
128 : // How often to collect metrics and send them to the metrics endpoint.
129 : pub metric_collection_interval: Duration,
130 : // How often to send unchanged cached metrics to the metrics endpoint.
131 : pub metric_collection_endpoint: Option<Url>,
132 : pub metric_collection_bucket: Option<RemoteStorageConfig>,
133 : pub synthetic_size_calculation_interval: Duration,
134 :
135 : pub disk_usage_based_eviction: Option<DiskUsageEvictionTaskConfig>,
136 :
137 : pub test_remote_failures: u64,
138 :
139 : pub ondemand_download_behavior_treat_error_as_warn: bool,
140 :
141 : /// How long will background tasks be delayed at most after initial load of tenants.
142 : ///
143 : /// Our largest initialization completions are in the range of 100-200s, so perhaps 10s works
144 : /// as we now isolate initial loading, initial logical size calculation and background tasks.
145 : /// Smaller nodes will have background tasks "not running" for this long unless every timeline
146 : /// has it's initial logical size calculated. Not running background tasks for some seconds is
147 : /// not terrible.
148 : pub background_task_maximum_delay: Duration,
149 :
150 : pub control_plane_api: Option<Url>,
151 :
152 : /// JWT token for use with the control plane API.
153 : pub control_plane_api_token: Option<SecretString>,
154 :
155 : pub import_pgdata_upcall_api: Option<Url>,
156 : pub import_pgdata_upcall_api_token: Option<SecretString>,
157 : pub import_pgdata_aws_endpoint_url: Option<Url>,
158 :
159 : /// If true, pageserver will make best-effort to operate without a control plane: only
160 : /// for use in major incidents.
161 : pub control_plane_emergency_mode: bool,
162 :
163 : /// How many heatmap uploads may be done concurrency: lower values implicitly deprioritize
164 : /// heatmap uploads vs. other remote storage operations.
165 : pub heatmap_upload_concurrency: usize,
166 :
167 : /// How many remote storage downloads may be done for secondary tenants concurrently. Implicitly
168 : /// deprioritises secondary downloads vs. remote storage operations for attached tenants.
169 : pub secondary_download_concurrency: usize,
170 :
171 : /// Maximum number of WAL records to be ingested and committed at the same time
172 : pub ingest_batch_size: u64,
173 :
174 : pub virtual_file_io_engine: virtual_file::IoEngineKind,
175 :
176 : pub max_vectored_read_bytes: MaxVectoredReadBytes,
177 :
178 : pub image_compression: ImageCompressionAlgorithm,
179 :
180 : /// Whether to offload archived timelines automatically
181 : pub timeline_offloading: bool,
182 :
183 : /// How many bytes of ephemeral layer content will we allow per kilobyte of RAM. When this
184 : /// is exceeded, we start proactively closing ephemeral layers to limit the total amount
185 : /// of ephemeral data.
186 : ///
187 : /// Setting this to zero disables limits on total ephemeral layer size.
188 : pub ephemeral_bytes_per_memory_kb: usize,
189 :
190 : pub l0_flush: crate::l0_flush::L0FlushConfig,
191 :
192 : /// Direct IO settings
193 : pub virtual_file_io_mode: virtual_file::IoMode,
194 :
195 : /// Optionally disable disk syncs (unsafe!)
196 : pub no_sync: bool,
197 :
198 : pub wal_receiver_protocol: PostgresClientProtocol,
199 :
200 : pub page_service_pipelining: pageserver_api::config::PageServicePipeliningConfig,
201 :
202 : pub get_vectored_concurrent_io: pageserver_api::config::GetVectoredConcurrentIo,
203 :
204 : /// Enable read path debugging. If enabled, read key errors will print a backtrace of the layer
205 : /// files read.
206 : pub enable_read_path_debugging: bool,
207 :
208 : /// Interpreted protocol feature: if enabled, validate that the logical WAL received from
209 : /// safekeepers does not have gaps.
210 : pub validate_wal_contiguity: bool,
211 :
212 : /// When set, the previously written to disk heatmap is loaded on tenant attach and used
213 : /// to avoid clobbering the heatmap from new, cold, attached locations.
214 : pub load_previous_heatmap: bool,
215 :
216 : /// When set, include visible layers in the next uploaded heatmaps of an unarchived timeline.
217 : pub generate_unarchival_heatmap: bool,
218 : }
219 :
220 : /// Token for authentication to safekeepers
221 : ///
222 : /// We do not want to store this in a PageServerConf because the latter may be logged
223 : /// and/or serialized at a whim, while the token is secret. Currently this token is the
224 : /// same for accessing all tenants/timelines, but may become per-tenant/per-timeline in
225 : /// the future, more tokens and auth may arrive for storage broker, completely changing the logic.
226 : /// Hence, we resort to a global variable for now instead of passing the token from the
227 : /// startup code to the connection code through a dozen layers.
228 : pub static SAFEKEEPER_AUTH_TOKEN: OnceCell<Arc<String>> = OnceCell::new();
229 :
230 : impl PageServerConf {
231 : //
232 : // Repository paths, relative to workdir.
233 : //
234 :
235 15508 : pub fn tenants_path(&self) -> Utf8PathBuf {
236 15508 : self.workdir.join(TENANTS_SEGMENT_NAME)
237 15508 : }
238 :
239 144 : pub fn deletion_prefix(&self) -> Utf8PathBuf {
240 144 : self.workdir.join("deletion")
241 144 : }
242 :
243 0 : pub fn metadata_path(&self) -> Utf8PathBuf {
244 0 : self.workdir.join("metadata.json")
245 0 : }
246 :
247 56 : pub fn deletion_list_path(&self, sequence: u64) -> Utf8PathBuf {
248 : // Encode a version in the filename, so that if we ever switch away from JSON we can
249 : // increment this.
250 : const VERSION: u8 = 1;
251 :
252 56 : self.deletion_prefix()
253 56 : .join(format!("{sequence:016x}-{VERSION:02x}.list"))
254 56 : }
255 :
256 48 : pub fn deletion_header_path(&self) -> Utf8PathBuf {
257 : // Encode a version in the filename, so that if we ever switch away from JSON we can
258 : // increment this.
259 : const VERSION: u8 = 1;
260 :
261 48 : self.deletion_prefix().join(format!("header-{VERSION:02x}"))
262 48 : }
263 :
264 15404 : pub fn tenant_path(&self, tenant_shard_id: &TenantShardId) -> Utf8PathBuf {
265 15404 : self.tenants_path().join(tenant_shard_id.to_string())
266 15404 : }
267 :
268 : /// Points to a place in pageserver's local directory,
269 : /// where certain tenant's LocationConf be stored.
270 0 : pub(crate) fn tenant_location_config_path(
271 0 : &self,
272 0 : tenant_shard_id: &TenantShardId,
273 0 : ) -> Utf8PathBuf {
274 0 : self.tenant_path(tenant_shard_id)
275 0 : .join(TENANT_LOCATION_CONFIG_NAME)
276 0 : }
277 :
278 452 : pub(crate) fn tenant_heatmap_path(&self, tenant_shard_id: &TenantShardId) -> Utf8PathBuf {
279 452 : self.tenant_path(tenant_shard_id)
280 452 : .join(TENANT_HEATMAP_BASENAME)
281 452 : }
282 :
283 14492 : pub fn timelines_path(&self, tenant_shard_id: &TenantShardId) -> Utf8PathBuf {
284 14492 : self.tenant_path(tenant_shard_id)
285 14492 : .join(TIMELINES_SEGMENT_NAME)
286 14492 : }
287 :
288 13576 : pub fn timeline_path(
289 13576 : &self,
290 13576 : tenant_shard_id: &TenantShardId,
291 13576 : timeline_id: &TimelineId,
292 13576 : ) -> Utf8PathBuf {
293 13576 : self.timelines_path(tenant_shard_id)
294 13576 : .join(timeline_id.to_string())
295 13576 : }
296 :
297 : /// Turns storage remote path of a file into its local path.
298 0 : pub fn local_path(&self, remote_path: &RemotePath) -> Utf8PathBuf {
299 0 : remote_path.with_base(&self.workdir)
300 0 : }
301 :
302 : //
303 : // Postgres distribution paths
304 : //
305 40 : pub fn pg_distrib_dir(&self, pg_version: u32) -> anyhow::Result<Utf8PathBuf> {
306 40 : let path = self.pg_distrib_dir.clone();
307 40 :
308 40 : #[allow(clippy::manual_range_patterns)]
309 40 : match pg_version {
310 40 : 14 | 15 | 16 | 17 => Ok(path.join(format!("v{pg_version}"))),
311 0 : _ => bail!("Unsupported postgres version: {}", pg_version),
312 : }
313 40 : }
314 :
315 20 : pub fn pg_bin_dir(&self, pg_version: u32) -> anyhow::Result<Utf8PathBuf> {
316 20 : Ok(self.pg_distrib_dir(pg_version)?.join("bin"))
317 20 : }
318 20 : pub fn pg_lib_dir(&self, pg_version: u32) -> anyhow::Result<Utf8PathBuf> {
319 20 : Ok(self.pg_distrib_dir(pg_version)?.join("lib"))
320 20 : }
321 :
322 : /// Parse a configuration file (pageserver.toml) into a PageServerConf struct,
323 : /// validating the input and failing on errors.
324 : ///
325 : /// This leaves any options not present in the file in the built-in defaults.
326 488 : pub fn parse_and_validate(
327 488 : id: NodeId,
328 488 : config_toml: pageserver_api::config::ConfigToml,
329 488 : workdir: &Utf8Path,
330 488 : ) -> anyhow::Result<Self> {
331 488 : let pageserver_api::config::ConfigToml {
332 488 : listen_pg_addr,
333 488 : listen_http_addr,
334 488 : listen_https_addr,
335 488 : ssl_key_file,
336 488 : ssl_cert_file,
337 488 : ssl_cert_reload_period,
338 488 : ssl_ca_file,
339 488 : availability_zone,
340 488 : wait_lsn_timeout,
341 488 : wal_redo_timeout,
342 488 : superuser,
343 488 : locale,
344 488 : page_cache_size,
345 488 : max_file_descriptors,
346 488 : pg_distrib_dir,
347 488 : http_auth_type,
348 488 : pg_auth_type,
349 488 : auth_validation_public_key_path,
350 488 : remote_storage,
351 488 : broker_endpoint,
352 488 : broker_keepalive_interval,
353 488 : log_format,
354 488 : metric_collection_interval,
355 488 : metric_collection_endpoint,
356 488 : metric_collection_bucket,
357 488 : synthetic_size_calculation_interval,
358 488 : disk_usage_based_eviction,
359 488 : test_remote_failures,
360 488 : ondemand_download_behavior_treat_error_as_warn,
361 488 : background_task_maximum_delay,
362 488 : control_plane_api,
363 488 : control_plane_api_token,
364 488 : control_plane_emergency_mode,
365 488 : import_pgdata_upcall_api,
366 488 : import_pgdata_upcall_api_token,
367 488 : import_pgdata_aws_endpoint_url,
368 488 : heatmap_upload_concurrency,
369 488 : secondary_download_concurrency,
370 488 : ingest_batch_size,
371 488 : max_vectored_read_bytes,
372 488 : image_compression,
373 488 : timeline_offloading,
374 488 : ephemeral_bytes_per_memory_kb,
375 488 : l0_flush,
376 488 : virtual_file_io_mode,
377 488 : concurrent_tenant_warmup,
378 488 : concurrent_tenant_size_logical_size_queries,
379 488 : virtual_file_io_engine,
380 488 : tenant_config,
381 488 : no_sync,
382 488 : wal_receiver_protocol,
383 488 : page_service_pipelining,
384 488 : get_vectored_concurrent_io,
385 488 : enable_read_path_debugging,
386 488 : validate_wal_contiguity,
387 488 : load_previous_heatmap,
388 488 : generate_unarchival_heatmap,
389 488 : } = config_toml;
390 :
391 488 : let mut conf = PageServerConf {
392 : // ------------------------------------------------------------
393 : // fields that are already fully validated by the ConfigToml Deserialize impl
394 : // ------------------------------------------------------------
395 488 : listen_pg_addr,
396 488 : listen_http_addr,
397 488 : listen_https_addr,
398 488 : ssl_key_file,
399 488 : ssl_cert_file,
400 488 : ssl_cert_reload_period,
401 488 : availability_zone,
402 488 : wait_lsn_timeout,
403 488 : wal_redo_timeout,
404 488 : superuser,
405 488 : locale,
406 488 : page_cache_size,
407 488 : max_file_descriptors,
408 488 : http_auth_type,
409 488 : pg_auth_type,
410 488 : auth_validation_public_key_path,
411 488 : remote_storage_config: remote_storage,
412 488 : broker_endpoint,
413 488 : broker_keepalive_interval,
414 488 : log_format,
415 488 : metric_collection_interval,
416 488 : metric_collection_endpoint,
417 488 : metric_collection_bucket,
418 488 : synthetic_size_calculation_interval,
419 488 : disk_usage_based_eviction,
420 488 : test_remote_failures,
421 488 : ondemand_download_behavior_treat_error_as_warn,
422 488 : background_task_maximum_delay,
423 488 : control_plane_api,
424 488 : control_plane_emergency_mode,
425 488 : heatmap_upload_concurrency,
426 488 : secondary_download_concurrency,
427 488 : ingest_batch_size,
428 488 : max_vectored_read_bytes,
429 488 : image_compression,
430 488 : timeline_offloading,
431 488 : ephemeral_bytes_per_memory_kb,
432 488 : import_pgdata_upcall_api,
433 488 : import_pgdata_upcall_api_token: import_pgdata_upcall_api_token.map(SecretString::from),
434 488 : import_pgdata_aws_endpoint_url,
435 488 : wal_receiver_protocol,
436 488 : page_service_pipelining,
437 488 : get_vectored_concurrent_io,
438 488 :
439 488 : // ------------------------------------------------------------
440 488 : // fields that require additional validation or custom handling
441 488 : // ------------------------------------------------------------
442 488 : workdir: workdir.to_owned(),
443 488 : pg_distrib_dir: pg_distrib_dir.unwrap_or_else(|| {
444 4 : std::env::current_dir()
445 4 : .expect("current_dir() failed")
446 4 : .try_into()
447 4 : .expect("current_dir() is not a valid Utf8Path")
448 488 : }),
449 488 : control_plane_api_token: control_plane_api_token.map(SecretString::from),
450 488 : id,
451 488 : default_tenant_conf: tenant_config,
452 488 : concurrent_tenant_warmup: ConfigurableSemaphore::new(concurrent_tenant_warmup),
453 488 : concurrent_tenant_size_logical_size_queries: ConfigurableSemaphore::new(
454 488 : concurrent_tenant_size_logical_size_queries,
455 488 : ),
456 488 : eviction_task_immitated_concurrent_logical_size_queries: ConfigurableSemaphore::new(
457 488 : // re-use `concurrent_tenant_size_logical_size_queries`
458 488 : concurrent_tenant_size_logical_size_queries,
459 488 : ),
460 488 : virtual_file_io_engine: match virtual_file_io_engine {
461 0 : Some(v) => v,
462 488 : None => match crate::virtual_file::io_engine_feature_test()
463 488 : .context("auto-detect virtual_file_io_engine")?
464 : {
465 488 : io_engine::FeatureTestResult::PlatformPreferred(v) => v, // make no noise
466 0 : io_engine::FeatureTestResult::Worse { engine, remark } => {
467 0 : // TODO: bubble this up to the caller so we can tracing::warn! it.
468 0 : eprintln!(
469 0 : "auto-detected IO engine is not platform-preferred: engine={engine:?} remark={remark:?}"
470 0 : );
471 0 : engine
472 : }
473 : },
474 : },
475 488 : l0_flush: l0_flush
476 488 : .map(crate::l0_flush::L0FlushConfig::from)
477 488 : .unwrap_or_default(),
478 488 : virtual_file_io_mode: virtual_file_io_mode.unwrap_or(virtual_file::IoMode::preferred()),
479 488 : no_sync: no_sync.unwrap_or(false),
480 488 : enable_read_path_debugging: enable_read_path_debugging.unwrap_or(false),
481 488 : validate_wal_contiguity: validate_wal_contiguity.unwrap_or(false),
482 488 : load_previous_heatmap: load_previous_heatmap.unwrap_or(true),
483 488 : generate_unarchival_heatmap: generate_unarchival_heatmap.unwrap_or(true),
484 488 : ssl_ca_certs: match ssl_ca_file {
485 0 : Some(ssl_ca_file) => {
486 0 : let buf = std::fs::read(ssl_ca_file)?;
487 0 : Certificate::from_pem_bundle(&buf)?
488 : }
489 488 : None => Vec::new(),
490 : },
491 : };
492 :
493 : // ------------------------------------------------------------
494 : // custom validation code that covers more than one field in isolation
495 : // ------------------------------------------------------------
496 :
497 488 : if conf.http_auth_type == AuthType::NeonJWT || conf.pg_auth_type == AuthType::NeonJWT {
498 0 : let auth_validation_public_key_path = conf
499 0 : .auth_validation_public_key_path
500 0 : .get_or_insert_with(|| workdir.join("auth_public_key.pem"));
501 0 : ensure!(
502 0 : auth_validation_public_key_path.exists(),
503 0 : format!(
504 0 : "Can't find auth_validation_public_key at '{auth_validation_public_key_path}'",
505 0 : )
506 : );
507 488 : }
508 :
509 488 : IndexEntry::validate_checkpoint_distance(conf.default_tenant_conf.checkpoint_distance)
510 488 : .map_err(anyhow::Error::msg)
511 488 : .with_context(|| {
512 0 : format!(
513 0 : "effective checkpoint distance is unsupported: {}",
514 0 : conf.default_tenant_conf.checkpoint_distance
515 0 : )
516 488 : })?;
517 :
518 488 : Ok(conf)
519 488 : }
520 :
521 : #[cfg(test)]
522 488 : pub fn test_repo_dir(test_name: &str) -> Utf8PathBuf {
523 488 : let test_output_dir = std::env::var("TEST_OUTPUT").unwrap_or("../tmp_check".into());
524 488 :
525 488 : let test_id = uuid::Uuid::new_v4();
526 488 : Utf8PathBuf::from(format!("{test_output_dir}/test_{test_name}_{test_id}"))
527 488 : }
528 :
529 484 : pub fn dummy_conf(repo_dir: Utf8PathBuf) -> Self {
530 484 : let pg_distrib_dir = Utf8PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../pg_install");
531 484 :
532 484 : let config_toml = pageserver_api::config::ConfigToml {
533 484 : wait_lsn_timeout: Duration::from_secs(60),
534 484 : wal_redo_timeout: Duration::from_secs(60),
535 484 : pg_distrib_dir: Some(pg_distrib_dir),
536 484 : metric_collection_interval: Duration::from_secs(60),
537 484 : synthetic_size_calculation_interval: Duration::from_secs(60),
538 484 : background_task_maximum_delay: Duration::ZERO,
539 484 : load_previous_heatmap: Some(true),
540 484 : generate_unarchival_heatmap: Some(true),
541 484 : ..Default::default()
542 484 : };
543 484 : PageServerConf::parse_and_validate(NodeId(0), config_toml, &repo_dir).unwrap()
544 484 : }
545 : }
546 :
547 0 : #[derive(serde::Deserialize, serde::Serialize)]
548 : #[serde(deny_unknown_fields)]
549 : pub struct PageserverIdentity {
550 : pub id: NodeId,
551 : }
552 :
553 : /// Configurable semaphore permits setting.
554 : ///
555 : /// Does not allow semaphore permits to be zero, because at runtime initially zero permits and empty
556 : /// semaphore cannot be distinguished, leading any feature using these to await forever (or until
557 : /// new permits are added).
558 : #[derive(Debug, Clone)]
559 : pub struct ConfigurableSemaphore {
560 : initial_permits: NonZeroUsize,
561 : inner: std::sync::Arc<tokio::sync::Semaphore>,
562 : }
563 :
564 : impl ConfigurableSemaphore {
565 : /// Initializse using a non-zero amount of permits.
566 : ///
567 : /// Require a non-zero initial permits, because using permits == 0 is a crude way to disable a
568 : /// feature such as [`Tenant::gather_size_inputs`]. Otherwise any semaphore using future will
569 : /// behave like [`futures::future::pending`], just waiting until new permits are added.
570 : ///
571 : /// [`Tenant::gather_size_inputs`]: crate::tenant::Tenant::gather_size_inputs
572 1464 : pub fn new(initial_permits: NonZeroUsize) -> Self {
573 1464 : ConfigurableSemaphore {
574 1464 : initial_permits,
575 1464 : inner: std::sync::Arc::new(tokio::sync::Semaphore::new(initial_permits.get())),
576 1464 : }
577 1464 : }
578 :
579 : /// Returns the configured amount of permits.
580 0 : pub fn initial_permits(&self) -> NonZeroUsize {
581 0 : self.initial_permits
582 0 : }
583 : }
584 :
585 : impl PartialEq for ConfigurableSemaphore {
586 0 : fn eq(&self, other: &Self) -> bool {
587 0 : // the number of permits can be increased at runtime, so we cannot really fulfill the
588 0 : // PartialEq value equality otherwise
589 0 : self.initial_permits == other.initial_permits
590 0 : }
591 : }
592 :
593 : impl Eq for ConfigurableSemaphore {}
594 :
595 : impl ConfigurableSemaphore {
596 0 : pub fn inner(&self) -> &std::sync::Arc<tokio::sync::Semaphore> {
597 0 : &self.inner
598 0 : }
599 : }
600 :
601 : #[cfg(test)]
602 : mod tests {
603 :
604 : use camino::Utf8PathBuf;
605 : use utils::id::NodeId;
606 :
607 : use super::PageServerConf;
608 :
609 : #[test]
610 4 : fn test_empty_config_toml_is_valid() {
611 4 : // we use Default impl of everything in this situation
612 4 : let input = r#"
613 4 : "#;
614 4 : let config_toml = toml_edit::de::from_str::<pageserver_api::config::ConfigToml>(input)
615 4 : .expect("empty config is valid");
616 4 : let workdir = Utf8PathBuf::from("/nonexistent");
617 4 : PageServerConf::parse_and_validate(NodeId(0), config_toml, &workdir)
618 4 : .expect("parse_and_validate");
619 4 : }
620 :
621 : /// If there's a typo in the pageserver config, we'd rather catch that typo
622 : /// and fail pageserver startup than silently ignoring the typo, leaving whoever
623 : /// made it in the believe that their config change is effective.
624 : ///
625 : /// The default in serde is to allow unknown fields, so, we rely
626 : /// on developer+review discipline to add `deny_unknown_fields` when adding
627 : /// new structs to the config, and these tests here as a regression test.
628 : ///
629 : /// The alternative to all of this would be to allow unknown fields in the config.
630 : /// To catch them, we could have a config check tool or mgmt API endpoint that
631 : /// compares the effective config with the TOML on disk and makes sure that
632 : /// the on-disk TOML is a strict subset of the effective config.
633 : mod unknown_fields_handling {
634 : macro_rules! test {
635 : ($short_name:ident, $input:expr) => {
636 : #[test]
637 20 : fn $short_name() {
638 20 : let input = $input;
639 20 : let err = toml_edit::de::from_str::<pageserver_api::config::ConfigToml>(&input)
640 20 : .expect_err("some_invalid_field is an invalid field");
641 20 : dbg!(&err);
642 20 : assert!(err.to_string().contains("some_invalid_field"));
643 20 : }
644 : };
645 : }
646 : use indoc::indoc;
647 :
648 : test!(
649 : toplevel,
650 : indoc! {r#"
651 : some_invalid_field = 23
652 : "#}
653 : );
654 :
655 : test!(
656 : toplevel_nested,
657 : indoc! {r#"
658 : [some_invalid_field]
659 : foo = 23
660 : "#}
661 : );
662 :
663 : test!(
664 : disk_usage_based_eviction,
665 : indoc! {r#"
666 : [disk_usage_based_eviction]
667 : some_invalid_field = 23
668 : "#}
669 : );
670 :
671 : test!(
672 : tenant_config,
673 : indoc! {r#"
674 : [tenant_config]
675 : some_invalid_field = 23
676 : "#}
677 : );
678 :
679 : test!(
680 : l0_flush,
681 : indoc! {r#"
682 : [l0_flush]
683 : mode = "direct"
684 : some_invalid_field = 23
685 : "#}
686 : );
687 :
688 : // TODO: fix this => https://github.com/neondatabase/neon/issues/8915
689 : // test!(
690 : // remote_storage_config,
691 : // indoc! {r#"
692 : // [remote_storage_config]
693 : // local_path = "/nonexistent"
694 : // some_invalid_field = 23
695 : // "#}
696 : // );
697 : }
698 : }
|
