feat(opds): add headless server on a Tauri-independent runtime

Cargo.toml

@@ -3,6 +3,7 @@ resolver = "2"
 members = [
     "crates/citadel-core",
     "crates/citadel-opds",
+    "crates/citadel-server",
     "crates/libcalibre",
     "src-tauri",
 ]

crates/citadel-opds/src/auth.rs

@@ -131,7 +131,7 @@ impl AuthCache {
 }
 
 impl OpdsBasicAuth {
-    pub(crate) fn disabled() -> Self {
+    pub fn disabled() -> Self {
         Self { enabled: None }
     }
 

crates/citadel-opds/src/network.rs

@@ -295,6 +295,8 @@ pub(crate) enum WaitingReason {
     SelectedInterfaceDown(String),
     SelectedInterfaceHasNoUsableAddress(String),
     LoopbackCannotBeShared(String),
+    NoConfiguredAddress,
+    InvalidConfiguredAddress(String),
 }
 
 impl WaitingReason {
@@ -315,6 +317,10 @@ impl WaitingReason {
             Self::LoopbackCannotBeShared(id) => {
                 format!("The selected interface ({id}) is loopback-only and cannot be shared.")
             }
+            Self::NoConfiguredAddress => "No explicit listener address was configured.".to_string(),
+            Self::InvalidConfiguredAddress(address) => {
+                format!("The configured listener address ({address}) is invalid.")
+            }
         }
     }
 }
@@ -326,6 +332,7 @@ impl WaitingReason {
 pub enum OpdsBindTarget {
     AllLocalNetworks,
     Interface { id: String },
+    Addresses { addresses: Vec<String> },
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -342,6 +349,20 @@ pub(crate) fn plan_bindings(
     target: &OpdsBindTarget,
     port: u16,
 ) -> BindPlan {
+    if let OpdsBindTarget::Addresses { addresses } = target {
+        if addresses.is_empty() {
+            return BindPlan::Wait(WaitingReason::NoConfiguredAddress);
+        }
+        let mut sockets = BTreeSet::new();
+        for address in addresses {
+            let Ok(address) = address.parse::<IpAddr>() else {
+                return BindPlan::Wait(WaitingReason::InvalidConfiguredAddress(address.clone()));
+            };
+            sockets.insert(SocketAddr::new(address, port));
+        }
+        return BindPlan::Listen(sockets);
+    }
+
     let selected = match target {
         OpdsBindTarget::AllLocalNetworks => interfaces
             .iter()
@@ -362,6 +383,7 @@ pub(crate) fn plan_bindings(
             }
             vec![interface]
         }
+        OpdsBindTarget::Addresses { .. } => unreachable!(),
     };
 
     let addresses = selected
@@ -374,6 +396,7 @@ pub(crate) fn plan_bindings(
             OpdsBindTarget::Interface { id } => {
                 WaitingReason::SelectedInterfaceHasNoUsableAddress(id.clone())
             }
+            OpdsBindTarget::Addresses { .. } => unreachable!(),
         })
     } else {
         BindPlan::Listen(addresses)
@@ -621,6 +644,37 @@ mod tests {
         );
     }
 
+    #[test]
+    fn explicit_addresses_do_not_depend_on_interface_enumeration() {
+        let plan = plan_bindings(
+            &[],
+            &OpdsBindTarget::Addresses {
+                addresses: vec!["127.0.0.1".to_string(), "::1".to_string()],
+            },
+            8080,
+        );
+        assert_eq!(
+            plan,
+            BindPlan::Listen(BTreeSet::from([
+                "127.0.0.1:8080".parse().unwrap(),
+                "[::1]:8080".parse().unwrap(),
+            ]))
+        );
+
+        assert_eq!(
+            plan_bindings(
+                &[],
+                &OpdsBindTarget::Addresses {
+                    addresses: vec!["not-an-address".to_string()],
+                },
+                8080,
+            ),
+            BindPlan::Wait(WaitingReason::InvalidConfiguredAddress(
+                "not-an-address".to_string()
+            ))
+        );
+    }
+
     #[test]
     fn public_interface_exposes_bindable_addresses_and_shareability() {
         let public = interface(

crates/citadel-opds/src/service.rs

@@ -401,7 +401,9 @@ impl OpdsService {
         };
 
         let mut servers = BTreeMap::new();
-        match snapshot_interfaces(self.inner.dependencies.interfaces.clone()).await {
+        match snapshot_target_interfaces(self.inner.dependencies.interfaces.clone(), &config.target)
+            .await
+        {
             Ok(interfaces) => {
                 apply_plan(
                     &interfaces,
@@ -587,6 +589,17 @@ async fn snapshot_interfaces(
         .map_err(|_| io::Error::other("interface snapshot task failed"))?
 }
 
+async fn snapshot_target_interfaces(
+    interfaces: Arc<dyn InterfaceSnapshots>,
+    target: &OpdsBindTarget,
+) -> io::Result<Vec<InterfaceSnapshot>> {
+    if matches!(target, OpdsBindTarget::Addresses { .. }) {
+        Ok(Vec::new())
+    } else {
+        snapshot_interfaces(interfaces).await
+    }
+}
+
 async fn active_library_id(source: Arc<dyn CatalogSource>) -> Option<String> {
     tokio::task::spawn_blocking(move || source.active_library_id().ok())
         .await
@@ -725,7 +738,7 @@ async fn monitor_service(
             continue;
         }
 
-        let snapshot = match snapshot_interfaces(interfaces.clone()).await {
+        let snapshot = match snapshot_target_interfaces(interfaces.clone(), &config.target).await {
             Ok(snapshot) => snapshot,
             Err(_) => {
                 shutdown_servers(&mut servers).await;

crates/citadel-server/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "citadel-server"
+version = "0.1.0"
+edition = "2021"
+rust-version.workspace = true
+description = "Headless Citadel OPDS server"
+
+[dependencies]
+chrono = "0.4.31"
+citadel-opds = { path = "../citadel-opds" }
+libcalibre = { path = "../libcalibre" }
+serde = { version = "1.0", features = ["derive"] }
+tokio = { version = "1.52.3", features = ["macros", "rt-multi-thread", "signal", "time"] }
+toml = "0.9"
+
+[dev-dependencies]
+base64 = "0.22"
+nix = { version = "0.30", features = ["signal"] }
+reqwest = { version = "0.12", features = ["blocking"] }
+tempfile = "3.8"

crates/citadel-server/example-config.toml

@@ -0,0 +1,13 @@
+libraryPath = "/srv/calibre-library"
+stateDirectory = "/var/lib/citadel"
+
+[sharing]
+port = 8080
+authenticationEnabled = true
+
+[sharing.target]
+type = "allLocalNetworks"
+
+[credentials]
+username = "reader"
+passwordEnvironment = "CITADEL_OPDS_PASSWORD"