fix(config): apply --service override before disk-usage validation

A searcher node started with `--service searcher` could log a misleading
"data dir volume too small" warning at startup, comparing its volume
against the indexer split-store and ingest queue disk budgets. A searcher
does not use those budgets, so the warning was wrong and misleading.

The cause was validation order: the CLI `--service` override was applied
after `load_node_config()` had already run validation, so the disk-usage
check ran against the default (all-services) set and counted indexer/ingest
budgets. This threads the service override through `load_node_config_with_env`
into `build_and_validate`, applying it where `enabled_services` is resolved,
before validation. The override takes precedence over the config file and
env vars, matching the previous post-load behavior.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: hushy

quickwit/quickwit-cli/src/lib.rs

@@ -230,14 +230,25 @@ pub fn start_actor_runtimes(
 }
 
 /// Loads a node config located at `config_uri` with the default storage configuration.
-async fn load_node_config(config_uri: &Uri) -> anyhow::Result<NodeConfig> {
+///
+/// When `service_override` is provided, it is applied before config validation so that
+/// service-dependent validation (e.g. the disk-usage check) reflects the actual runtime service
+/// set (e.g. `--service searcher`).
+async fn load_node_config(
+    config_uri: &Uri,
+    service_override: Option<&HashSet<QuickwitService>>,
+) -> anyhow::Result<NodeConfig> {
     let config_content = load_file(&StorageResolver::unconfigured(), config_uri)
         .await
         .context("failed to load node config")?;
     let config_format = ConfigFormat::sniff_from_uri(config_uri)?;
-    let config = NodeConfig::load(config_format, config_content.as_slice())
-        .await
-        .with_context(|| format!("failed to parse node config `{config_uri}`"))?;
+    let config = NodeConfig::load_with_service_override(
+        config_format,
+        config_content.as_slice(),
+        service_override,
+    )
+    .await
+    .with_context(|| format!("failed to parse node config `{config_uri}`"))?;
     info!(config_uri=%config_uri, config=?config, "loaded node config");
     Ok(config)
 }

quickwit/quickwit-cli/src/service.rs

@@ -117,15 +117,13 @@ impl RunCliCommand {
         debug!(args = ?self, "run-service");
         let version_text = BuildInfo::get_version_text();
         info!("quickwit version: {version_text}");
-        let mut node_config = load_node_config(&self.config_uri).await?;
+        let node_config = load_node_config(&self.config_uri, self.services.as_ref()).await?;
+        if let Some(services) = &self.services {
+            info!(services = %services.iter().join(", "), "services set from CLI override");
+        }
         let (storage_resolver, metastore_resolver) =
             get_resolvers(&node_config.storage_configs, &node_config.metastore_configs);
         crate::busy_detector::set_enabled(true);
-
-        if let Some(services) = &self.services {
-            info!(services = %services.iter().join(", "), "setting services from override");
-            node_config.enabled_services.clone_from(services);
-        }
         // TODO move in serve quickwit?
         let runtimes_config = RuntimesConfig::default();
         start_actor_runtimes(runtimes_config, &node_config.enabled_services)?;

quickwit/quickwit-cli/src/tool.rs

@@ -402,7 +402,7 @@ pub async fn local_ingest_docs_cli(args: LocalIngestDocsArgs) -> anyhow::Result<
     debug!(args=?args, "local-ingest-docs");
     println!("❯ Ingesting documents locally...");
 
-    let config = load_node_config(&args.config_uri).await?;
+    let config = load_node_config(&args.config_uri, None).await?;
     let (storage_resolver, metastore_resolver) =
         get_resolvers(&config.storage_configs, &config.metastore_configs);
     let mut metastore = metastore_resolver.resolve(&config.metastore_uri).await?;
@@ -536,7 +536,7 @@ pub async fn local_ingest_docs_cli(args: LocalIngestDocsArgs) -> anyhow::Result<
 pub async fn local_search_cli(args: LocalSearchArgs) -> anyhow::Result<()> {
     debug!(args=?args, "local-search");
     println!("❯ Searching directly on the index storage (without calling REST API)...");
-    let config = load_node_config(&args.config_uri).await?;
+    let config = load_node_config(&args.config_uri, None).await?;
     let (storage_resolver, metastore_resolver) =
         get_resolvers(&config.storage_configs, &config.metastore_configs);
     let metastore: MetastoreServiceClient =
@@ -574,7 +574,7 @@ pub async fn local_search_cli(args: LocalSearchArgs) -> anyhow::Result<()> {
 pub async fn merge_cli(args: MergeArgs) -> anyhow::Result<()> {
     debug!(args=?args, "run-merge-operations");
     println!("❯ Merging splits locally...");
-    let config = load_node_config(&args.config_uri).await?;
+    let config = load_node_config(&args.config_uri, None).await?;
     let (storage_resolver, metastore_resolver) =
         get_resolvers(&config.storage_configs, &config.metastore_configs);
     let mut metastore = metastore_resolver.resolve(&config.metastore_uri).await?;
@@ -662,7 +662,7 @@ pub async fn garbage_collect_index_cli(args: GarbageCollectIndexArgs) -> anyhow:
     debug!(args=?args, "garbage-collect-index");
     println!("❯ Garbage collecting index...");
 
-    let config = load_node_config(&args.config_uri).await?;
+    let config = load_node_config(&args.config_uri, None).await?;
     let (storage_resolver, metastore_resolver) =
         get_resolvers(&config.storage_configs, &config.metastore_configs);
     let metastore = metastore_resolver.resolve(&config.metastore_uri).await?;
@@ -792,7 +792,7 @@ async fn extract_split_cli(args: ExtractSplitArgs) -> anyhow::Result<()> {
     debug!(args=?args, "extract-split");
     println!("❯ Extracting split...");
 
-    let config = load_node_config(&args.config_uri).await?;
+    let config = load_node_config(&args.config_uri, None).await?;
     let (storage_resolver, metastore_resolver) =
         get_resolvers(&config.storage_configs, &config.metastore_configs);
     let metastore = metastore_resolver.resolve(&config.metastore_uri).await?;

quickwit/quickwit-config/src/node_config/mod.rs

@@ -911,8 +911,22 @@ impl NodeConfig {
 
     /// Parses and validates a [`NodeConfig`] from a given URI and config content.
     pub async fn load(config_format: ConfigFormat, config_content: &[u8]) -> anyhow::Result<Self> {
+        Self::load_with_service_override(config_format, config_content, None).await
+    }
+
+    /// Parses and validates a [`NodeConfig`], applying `service_override` before validation so
+    /// service-dependent validation (e.g. the disk-usage check) uses the actual runtime service
+    /// set rather than the pre-override default (e.g. when `--service searcher` is passed via the
+    /// CLI).
+    pub async fn load_with_service_override(
+        config_format: ConfigFormat,
+        config_content: &[u8],
+        service_override: Option<&HashSet<QuickwitService>>,
+    ) -> anyhow::Result<Self> {
         let env_vars = env::vars().collect::<HashMap<_, _>>();
-        let config = load_node_config_with_env(config_format, config_content, &env_vars).await?;
+        let config =
+            load_node_config_with_env(config_format, config_content, service_override, &env_vars)
+                .await?;
         if !config.data_dir_path.try_exists()? {
             bail!(
                 "data dir `{}` does not exist",