Make rabbitmq and LSPS2 config optional when features are enabled

Allow building with features enabled but unconfigured so we can
distribute single binaries and Docker images with all features compiled
in, letting users opt-in via config at runtime.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: benthecarman

ldk-server/src/io/events/event_publisher.rs

@@ -52,11 +52,9 @@ pub trait EventPublisher: Send + Sync {
 }
 
 /// A no-op implementation of the [`EventPublisher`] trait.
-#[cfg(not(feature = "events-rabbitmq"))]
 pub(crate) struct NoopEventPublisher;
 
 #[async_trait]
-#[cfg(not(feature = "events-rabbitmq"))]
 impl EventPublisher for NoopEventPublisher {
 	/// Publishes an event to a no-op sink, effectively discarding it.
 	///

ldk-server/src/main.rs

@@ -204,9 +204,9 @@ fn main() {
 
 	// LSPS2 support is highly experimental and for testing purposes only.
 	#[cfg(feature = "experimental-lsps2-support")]
-	builder.set_liquidity_provider_lsps2(
-		config_file.lsps2_service_config.expect("Missing liquidity.lsps2_server config"),
-	);
+	if let Some(lsps2_config) = config_file.lsps2_service_config {
+		builder.set_liquidity_provider_lsps2(lsps2_config);
+	}
 
 	let runtime = match tokio::runtime::Builder::new_multi_thread().enable_all().build() {
 		Ok(runtime) => Arc::new(runtime),
@@ -246,15 +246,21 @@ fn main() {
 
 	#[cfg(not(feature = "events-rabbitmq"))]
 	let event_publisher: Arc<dyn EventPublisher> =
-		Arc::new(crate::io::events::event_publisher::NoopEventPublisher);
+		Arc::new(io::events::event_publisher::NoopEventPublisher);
 
 	#[cfg(feature = "events-rabbitmq")]
 	let event_publisher: Arc<dyn EventPublisher> = {
-		let rabbitmq_config = RabbitMqConfig {
-			connection_string: config_file.rabbitmq_connection_string,
-			exchange_name: config_file.rabbitmq_exchange_name,
-		};
-		Arc::new(RabbitMqEventPublisher::new(rabbitmq_config))
+		match (config_file.rabbitmq_connection_string, config_file.rabbitmq_exchange_name) {
+			(Some(connection_string), Some(exchange_name)) => {
+				let rabbitmq_config = RabbitMqConfig { connection_string, exchange_name };
+				Arc::new(RabbitMqEventPublisher::new(rabbitmq_config))
+			},
+			(None, None) => Arc::new(io::events::event_publisher::NoopEventPublisher),
+			_ => {
+				error!("Invalid RabbitMQ connection string or exchange name");
+				std::process::exit(-1);
+			},
+		}
 	};
 
 	info!("Starting up...");

ldk-server/src/util/config.rs

@@ -46,8 +46,8 @@ pub struct Config {
 	pub rest_service_addr: SocketAddr,
 	pub storage_dir_path: Option<String>,
 	pub chain_source: ChainSource,
-	pub rabbitmq_connection_string: String,
-	pub rabbitmq_exchange_name: String,
+	pub rabbitmq_connection_string: Option<String>,
+	pub rabbitmq_exchange_name: Option<String>,
 	pub lsps2_service_config: Option<LSPS2ServiceConfig>,
 	pub log_level: LevelFilter,
 	pub log_file_path: Option<String>,
@@ -155,8 +155,10 @@ impl ConfigBuilder {
 		}
 
 		if let Some(rabbitmq) = toml.rabbitmq {
-			self.rabbitmq_connection_string = Some(rabbitmq.connection_string);
-			self.rabbitmq_exchange_name = Some(rabbitmq.exchange_name);
+			self.rabbitmq_connection_string =
+				rabbitmq.connection_string.or(self.rabbitmq_connection_string.clone());
+			self.rabbitmq_exchange_name =
+				rabbitmq.exchange_name.or(self.rabbitmq_exchange_name.clone());
 		}
 
 		if let Some(liquidity) = toml.liquidity {
@@ -325,45 +327,19 @@ impl ConfigBuilder {
 			.transpose()?
 			.unwrap_or(LevelFilter::Debug);
 
-		#[cfg(feature = "events-rabbitmq")]
-		let (rabbitmq_connection_string, rabbitmq_exchange_name) = {
-			let connection_string = self.rabbitmq_connection_string.ok_or_else(|| io::Error::new(
-				io::ErrorKind::InvalidInput,
-				"Both `rabbitmq.connection_string` and `rabbitmq.exchange_name` must be configured if enabling `events-rabbitmq` feature."
-			))?;
-			let exchange_name = self.rabbitmq_exchange_name.ok_or_else(|| io::Error::new(
-				io::ErrorKind::InvalidInput,
-				"Both `rabbitmq.connection_string` and `rabbitmq.exchange_name` must be configured if enabling `events-rabbitmq` feature."
-			))?;
-
-			if connection_string.is_empty() || exchange_name.is_empty() {
-				return Err(io::Error::new(
-					io::ErrorKind::InvalidInput,
-					"Both `rabbitmq.connection_string` and `rabbitmq.exchange_name` must be configured if enabling `events-rabbitmq` feature."
-				));
-			}
-
-			(connection_string, exchange_name)
-		};
-
-		#[cfg(not(feature = "events-rabbitmq"))]
-		let (rabbitmq_connection_string, rabbitmq_exchange_name) = (String::new(), String::new());
-
-		#[cfg(feature = "experimental-lsps2-support")]
-		let lsps2_service_config = {
-			let liquidity = self.lsps2.ok_or_else(|| io::Error::new(
-				io::ErrorKind::InvalidInput,
-				"`liquidity.lsps2_service` must be defined in config if enabling `experimental-lsps2-support` feature."
-			))?;
-			let lsps2_service = liquidity.lsps2_service.ok_or_else(|| io::Error::new(
-				io::ErrorKind::InvalidInput,
-				"`liquidity.lsps2_service` must be defined in config if enabling `experimental-lsps2-support` feature."
-			))?;
-			Some(lsps2_service.into())
-		};
+		let (rabbitmq_connection_string, rabbitmq_exchange_name) =
+			match (self.rabbitmq_connection_string, self.rabbitmq_exchange_name) {
+				(Some(conn), Some(exchange)) => (Some(conn), Some(exchange)),
+				(None, None) => (None, None),
+				_ => {
+					return Err(io::Error::new(
+						io::ErrorKind::InvalidInput,
+						"Both `rabbitmq.connection_string` and `rabbitmq.exchange_name` must be configured together.",
+					));
+				},
+			};
 
-		#[cfg(not(feature = "experimental-lsps2-support"))]
-		let lsps2_service_config = None;
+		let lsps2_service_config = self.lsps2.and_then(|l| l.lsps2_service).map(|s| s.into());
 
 		Ok(Config {
 			network,
@@ -445,8 +421,8 @@ struct LogConfig {
 
 #[derive(Deserialize, Serialize)]
 struct RabbitmqConfig {
-	connection_string: String,
-	exchange_name: String,
+	connection_string: Option<String>,
+	exchange_name: Option<String>,
 }
 
 #[derive(Deserialize, Serialize)]
@@ -743,13 +719,6 @@ mod tests {
 
 		let alias = "LDK Server";
 
-		#[cfg(feature = "events-rabbitmq")]
-		let (expected_rabbit_conn, expected_rabbit_exchange) =
-			("rabbitmq_connection_string".to_string(), "rabbitmq_exchange_name".to_string());
-
-		#[cfg(not(feature = "events-rabbitmq"))]
-		let (expected_rabbit_conn, expected_rabbit_exchange) = (String::new(), String::new());
-
 		let expected = Config {
 			listening_addrs: Some(vec![SocketAddress::from_str("localhost:3001").unwrap()]),
 			announcement_addrs: Some(vec![SocketAddress::from_str("54.3.7.81:3001").unwrap()]),
@@ -768,8 +737,8 @@ mod tests {
 				rpc_user: "bitcoind-testuser".to_string(),
 				rpc_password: "bitcoind-testpassword".to_string(),
 			},
-			rabbitmq_connection_string: expected_rabbit_conn,
-			rabbitmq_exchange_name: expected_rabbit_exchange,
+			rabbitmq_connection_string: Some("rabbitmq_connection_string".to_string()),
+			rabbitmq_exchange_name: Some("rabbitmq_exchange_name".to_string()),
 			lsps2_service_config: Some(LSPS2ServiceConfig {
 				require_token: None,
 				advertise_service: false,
@@ -795,7 +764,6 @@ mod tests {
 		assert_eq!(config.chain_source, expected.chain_source);
 		assert_eq!(config.rabbitmq_connection_string, expected.rabbitmq_connection_string);
 		assert_eq!(config.rabbitmq_exchange_name, expected.rabbitmq_exchange_name);
-		#[cfg(feature = "experimental-lsps2-support")]
 		assert_eq!(config.lsps2_service_config.is_some(), expected.lsps2_service_config.is_some());
 		assert_eq!(config.log_level, expected.log_level);
 		assert_eq!(config.log_file_path, expected.log_file_path);
@@ -957,46 +925,6 @@ mod tests {
 		assert_eq!(error.to_string(), "Must set a single chain source, multiple were configured");
 	}
 
-	#[test]
-	fn test_config_optional_values() {
-		let storage_path = std::env::temp_dir();
-		let config_file_name = "test_only_required_config.toml";
-
-		let mut args_config = empty_args_config();
-		args_config.config_file =
-			Some(storage_path.join(config_file_name).to_string_lossy().to_string());
-
-		// Test with optional values not specified in the config file
-		let toml_config = r#"
-			[node]
-			network = "regtest"
-			rest_service_address = "127.0.0.1:3002"
-
-			[bitcoind]
-			rpc_address = "127.0.0.1:8332"
-			rpc_user = "bitcoind-testuser"
-			rpc_password = "bitcoind-testpassword"
-
-			[rabbitmq]
-			connection_string = "rabbitmq_connection_string"
-			exchange_name = "rabbitmq_exchange_name"
-
-			[liquidity.lsps2_service]
-			advertise_service = false
-			channel_opening_fee_ppm = 1000            # 0.1% fee
-			channel_over_provisioning_ppm = 500000    # 50% extra capacity
-			min_channel_opening_fee_msat = 10000000   # 10,000 satoshis
-			min_channel_lifetime = 4320               # ~30 days
-			max_client_to_self_delay = 1440           # ~10 days
-			min_payment_size_msat = 10000000          # 10,000 satoshis
-			max_payment_size_msat = 25000000000       # 0.25 BTC
-			client_trusts_lsp = true
-			"#;
-
-		fs::write(storage_path.join(config_file_name), toml_config).unwrap();
-		assert!(load_config(&args_config).is_ok());
-	}
-
 	#[test]
 	fn test_config_missing_fields_in_file() {
 		let storage_path = std::env::temp_dir();
@@ -1019,22 +947,6 @@ mod tests {
 			};
 		}
 
-		#[cfg(feature = "experimental-lsps2-support")]
-		{
-			validate_missing!(
-				"[liquidity.lsps2_service]",
-				"`liquidity.lsps2_service` must be defined in config if enabling `experimental-lsps2-support` feature."
-			);
-		}
-
-		#[cfg(feature = "events-rabbitmq")]
-		{
-			validate_missing!(
-				"[rabbitmq]",
-				"Both `rabbitmq.connection_string` and `rabbitmq.exchange_name` must be configured if enabling `events-rabbitmq` feature."
-			);
-		}
-
 		validate_missing!("rpc_password", missing_field_msg("bitcoind_rpc_password"));
 		validate_missing!("rpc_user", missing_field_msg("bitcoind_rpc_user"));
 		validate_missing!("rpc_address", missing_field_msg("bitcoind_rpc_address"));
@@ -1051,8 +963,6 @@ mod tests {
 	}
 
 	#[test]
-	#[cfg(not(feature = "experimental-lsps2-support"))]
-	#[cfg(not(feature = "events-rabbitmq"))]
 	fn test_config_from_args_config() {
 		let args_config = default_args_config();
 		let config = load_config(&args_config).unwrap();
@@ -1082,8 +992,8 @@ mod tests {
 				rpc_user: args_config.bitcoind_rpc_user.unwrap(),
 				rpc_password: args_config.bitcoind_rpc_password.unwrap(),
 			},
-			rabbitmq_connection_string: String::new(),
-			rabbitmq_exchange_name: String::new(),
+			rabbitmq_connection_string: None,
+			rabbitmq_exchange_name: None,
 			lsps2_service_config: None,
 			log_level: LevelFilter::Trace,
 			log_file_path: Some("/var/log/ldk-server.log".to_string()),
@@ -1101,8 +1011,6 @@ mod tests {
 	}
 
 	#[test]
-	#[cfg(not(feature = "experimental-lsps2-support"))]
-	#[cfg(not(feature = "events-rabbitmq"))]
 	fn test_config_missing_fields_in_args_config() {
 		macro_rules! validate_missing {
 			($field:ident, $err_msg:expr) => {
@@ -1133,13 +1041,6 @@ mod tests {
 		args_config.config_file =
 			Some(storage_path.join(config_file_name).to_string_lossy().to_string());
 
-		#[cfg(feature = "events-rabbitmq")]
-		let (expected_rabbit_conn, expected_rabbit_exchange) =
-			("rabbitmq_connection_string".to_string(), "rabbitmq_exchange_name".to_string());
-
-		#[cfg(not(feature = "events-rabbitmq"))]
-		let (expected_rabbit_conn, expected_rabbit_exchange) = (String::new(), String::new());
-
 		let (host, port) =
 			parse_host_port(args_config.bitcoind_rpc_address.clone().unwrap().as_str()).unwrap();
 
@@ -1171,8 +1072,8 @@ mod tests {
 				rpc_user: args_config.bitcoind_rpc_user.unwrap(),
 				rpc_password: args_config.bitcoind_rpc_password.unwrap(),
 			},
-			rabbitmq_connection_string: expected_rabbit_conn,
-			rabbitmq_exchange_name: expected_rabbit_exchange,
+			rabbitmq_connection_string: Some("rabbitmq_connection_string".to_string()),
+			rabbitmq_exchange_name: Some("rabbitmq_exchange_name".to_string()),
 			lsps2_service_config: Some(LSPS2ServiceConfig {
 				require_token: None,
 				advertise_service: false,
@@ -1197,27 +1098,41 @@ mod tests {
 		assert_eq!(config.chain_source, expected.chain_source);
 		assert_eq!(config.rabbitmq_connection_string, expected.rabbitmq_connection_string);
 		assert_eq!(config.rabbitmq_exchange_name, expected.rabbitmq_exchange_name);
-		#[cfg(feature = "experimental-lsps2-support")]
 		assert_eq!(config.lsps2_service_config.is_some(), expected.lsps2_service_config.is_some());
 	}
 
 	#[test]
-	#[cfg(feature = "events-rabbitmq")]
-	fn test_error_if_rabbitmq_feature_without_valid_config_file() {
-		let args_config = empty_args_config();
-		let result = load_config(&args_config);
-		assert!(result.is_err());
-		let err = result.unwrap_err();
-		assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
-	}
+	fn test_error_if_partial_rabbitmq_config() {
+		let storage_path = std::env::temp_dir();
+		let config_file_name = "test_error_if_partial_rabbitmq_config.toml";
 
-	#[test]
-	#[cfg(feature = "experimental-lsps2-support")]
-	fn test_error_if_lsps2_feature_without_valid_config_file() {
-		let args_config = empty_args_config();
+		let mut args_config = empty_args_config();
+		args_config.config_file =
+			Some(storage_path.join(config_file_name).to_string_lossy().to_string());
+
+		// Only connection_string set, missing exchange_name
+		let toml_config = r#"
+			[node]
+			network = "regtest"
+			rest_service_address = "127.0.0.1:3002"
+
+			[bitcoind]
+			rpc_address = "127.0.0.1:8332"
+			rpc_user = "bitcoind-testuser"
+			rpc_password = "bitcoind-testpassword"
+
+			[rabbitmq]
+			connection_string = "amqp://localhost"
+			"#;
+
+		fs::write(storage_path.join(config_file_name), toml_config).unwrap();
 		let result = load_config(&args_config);
 		assert!(result.is_err());
 		let err = result.unwrap_err();
 		assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
+		assert_eq!(
+			err.to_string(),
+			"Both `rabbitmq.connection_string` and `rabbitmq.exchange_name` must be configured together."
+		);
 	}
 }