torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
//! Host-owned filesystem layout: content vs ledger/state roots.

use std::path::{Path, PathBuf};

use crate::config::Config;

/// Resolved paths for one torrent: payload content vs metadata/ledger sidecars.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TorrentLayout {
    /// Absolute content directory: `{download_dir}/{info_hash}/`.
    pub content_root: PathBuf,
    /// Jail root for resume/ledger, manifest, and parity sidecars.
    ///
    /// Legacy (no `state_dir`): same as `content_root` (sidecars under `.torrentdht/`).
    /// Host `state_dir`: `{state_dir}/torrents/{info_hash}/`.
    pub state_root: PathBuf,
}

impl Config {
    /// Client-wide state directory (peer reconnect store, DHT routing snapshot).
    ///
    /// Defaults to `{download_dir}/.torrentdht` when `state_dir` is unset.
    pub fn client_state_root(&self) -> PathBuf {
        self.state_dir
            .clone()
            .unwrap_or_else(|| self.download_dir.join(".torrentdht"))
    }

    /// `(jail_root, relative_path)` for a client-wide state file.
    ///
    /// With host `state_dir`: jail is `state_dir`, relative is `name` (e.g. `peers.kdl`).
    /// Legacy: jail is `download_dir`, relative is `.torrentdht/{name}`.
    pub fn client_state_file(&self, name: &str) -> (PathBuf, PathBuf) {
        if self.state_dir.is_some() {
            (self.client_state_root(), PathBuf::from(name))
        } else {
            (
                self.download_dir.clone(),
                PathBuf::from(".torrentdht").join(name),
            )
        }
    }

    /// Resolve content + ledger/state roots for a torrent info-hash (hex).
    pub fn torrent_layout(&self, info_hash_hex: &str) -> TorrentLayout {
        let content_root = self.download_dir.join(info_hash_hex);
        let state_root = if let Some(state) = &self.state_dir {
            state.join("torrents").join(info_hash_hex)
        } else {
            content_root.clone()
        };
        TorrentLayout {
            content_root,
            state_root,
        }
    }

    /// Absolute path to a torrent's resume/ledger file (for display / open).
    pub fn resume_path(&self, info_hash_hex: &str) -> PathBuf {
        let layout = self.torrent_layout(info_hash_hex);
        layout.state_root.join(".torrentdht").join("resume.kdl")
    }
}

/// Ensure a host state directory exists and is a real (non-symlink) directory.
pub fn ensure_host_dir(path: &Path) -> crate::error::Result<()> {
    use crate::error::Error;
    if !path.exists() {
        std::fs::create_dir_all(path).map_err(Error::from)?;
    }
    let meta = std::fs::symlink_metadata(path).map_err(Error::from)?;
    if meta.file_type().is_symlink() || !meta.is_dir() {
        return Err(Error::Config(format!(
            "host directory must be a real directory: {}",
            path.display()
        )));
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn legacy_layout_keeps_state_beside_content() {
        let cfg = Config {
            download_dir: PathBuf::from("/data/downloads"),
            state_dir: None,
            ..Config::default()
        };
        let layout = cfg.torrent_layout("abc");
        assert_eq!(layout.content_root, PathBuf::from("/data/downloads/abc"));
        assert_eq!(layout.state_root, layout.content_root);
        let (jail, rel) = cfg.client_state_file("peers.kdl");
        assert_eq!(jail, PathBuf::from("/data/downloads"));
        assert_eq!(rel, PathBuf::from(".torrentdht/peers.kdl"));
    }

    #[test]
    fn host_state_dir_separates_ledger_from_content() {
        let cfg = Config {
            download_dir: PathBuf::from("/data/downloads"),
            state_dir: Some(PathBuf::from("/var/torrentdht")),
            ..Config::default()
        };
        let layout = cfg.torrent_layout("abc");
        assert_eq!(layout.content_root, PathBuf::from("/data/downloads/abc"));
        assert_eq!(
            layout.state_root,
            PathBuf::from("/var/torrentdht/torrents/abc")
        );
        let (jail, rel) = cfg.client_state_file("dht-routing.kdl");
        assert_eq!(jail, PathBuf::from("/var/torrentdht"));
        assert_eq!(rel, PathBuf::from("dht-routing.kdl"));
    }
}