ferripfs_network/

daemon.rs

// Ported from: kubo/cmd/ipfs/kubo/daemon.go
// Kubo version: v0.39.0
//
// Original work: Copyright (c) Protocol Labs, Inc.
// Port: Copyright (c) 2026 ferripfs contributors
// SPDX-License-Identifier: MIT OR Apache-2.0

//! Daemon process management.

use std::fs;
use std::path::{Path, PathBuf};
use std::sync::Arc;

use libp2p::identity::Keypair;
use tokio::sync::oneshot;

use ferripfs_config::Config;
use ferripfs_repo::{FsRepo, RepoLock, API_FILE};

use crate::{
    host::{HostConfig, NetworkHost},
    NetworkError, NetworkResult, PeerInfo,
};

/// Configuration for the daemon.
#[derive(Debug, Clone)]
pub struct DaemonConfig {
    /// Repository path
    pub repo_path: PathBuf,
    /// Run in offline mode (no network)
    pub offline: bool,
    /// Enable mDNS discovery
    pub enable_mdns: bool,
    /// Enable pubsub
    pub enable_pubsub: bool,
    /// Enable IPNS pubsub
    pub enable_ipns_pubsub: bool,
    /// Routing mode (dht, dhtclient, dhtserver, none)
    pub routing: String,
}

impl Default for DaemonConfig {
    fn default() -> Self {
        Self {
            repo_path: PathBuf::new(),
            offline: false,
            enable_mdns: true,
            enable_pubsub: false,
            enable_ipns_pubsub: false,
            routing: "dht".into(),
        }
    }
}

/// Handle to a running daemon.
pub struct DaemonHandle {
    /// Shutdown sender
    shutdown_tx: Option<oneshot::Sender<()>>,
    /// Network host
    host: Arc<NetworkHost>,
    /// Repository lock
    _lock: RepoLock,
    /// Repository path
    repo_path: PathBuf,
}

impl DaemonHandle {
    /// Get the network host.
    pub fn host(&self) -> &NetworkHost {
        &self.host
    }

    /// Get peer info.
    pub async fn peer_info(&self) -> NetworkResult<PeerInfo> {
        self.host.peer_info().await
    }

    /// Shutdown the daemon.
    pub async fn shutdown(mut self) -> NetworkResult<()> {
        // Signal shutdown
        if let Some(tx) = self.shutdown_tx.take() {
            let _ = tx.send(());
        }

        // Shutdown host
        self.host.shutdown().await?;

        // Remove API file
        let api_file = self.repo_path.join(API_FILE);
        let _ = fs::remove_file(&api_file);

        Ok(())
    }
}

impl Drop for DaemonHandle {
    fn drop(&mut self) {
        // Clean up API file
        let api_file = self.repo_path.join(API_FILE);
        let _ = fs::remove_file(&api_file);
    }
}

/// The ferripfs daemon.
pub struct Daemon;

impl Daemon {
    /// Start the daemon.
    pub async fn start(config: DaemonConfig) -> NetworkResult<DaemonHandle> {
        let repo_path = config.repo_path.clone();

        // Check if repo is initialized
        if !FsRepo::is_initialized(&repo_path) {
            return Err(NetworkError::Daemon(format!(
                "Repository not initialized at {}. Run 'ferripfs init' first.",
                repo_path.display()
            )));
        }

        // Acquire repository lock
        let lock = RepoLock::acquire(&repo_path).map_err(|e| {
            if matches!(e, ferripfs_repo::RepoError::Locked) {
                NetworkError::AlreadyRunning
            } else {
                NetworkError::Repo(e)
            }
        })?;

        // Open repository
        let repo = FsRepo::open(&repo_path)?;
        let ferripfs_config = repo.config().clone();

        // Load keypair from identity
        let keypair = Self::load_keypair(&ferripfs_config)?;

        // Create host config
        let host_config = if config.offline {
            // Offline mode - no listening
            HostConfig {
                keypair,
                listen_addrs: Vec::new(),
                bootstrap_peers: Vec::new(),
                swarm_config: crate::swarm::SwarmConfig {
                    mdns_enabled: false,
                    relay_enabled: false,
                    ..Default::default()
                },
            }
        } else {
            HostConfig::from_config(&ferripfs_config, keypair)
        };

        // Start network host
        let host = NetworkHost::start(host_config).await?;
        let host = Arc::new(host);

        // Write API file
        let api_addr = ferripfs_config
            .addresses
            .api
            .first()
            .cloned()
            .unwrap_or_else(|| "/ip4/127.0.0.1/tcp/5001".into());
        let api_file = repo_path.join(API_FILE);
        fs::write(&api_file, &api_addr).map_err(NetworkError::Io)?;

        // Create shutdown channel
        let (shutdown_tx, _shutdown_rx) = oneshot::channel();

        Ok(DaemonHandle {
            shutdown_tx: Some(shutdown_tx),
            host,
            _lock: lock,
            repo_path,
        })
    }

    /// Load keypair from config identity.
    fn load_keypair(config: &Config) -> NetworkResult<Keypair> {
        // Get private key from config
        let priv_key_str = config
            .identity
            .priv_key
            .as_ref()
            .ok_or_else(|| NetworkError::Init("Identity.PrivKey not found in config".into()))?;

        // Decode base64 private key
        use base64::Engine;
        let key_bytes = base64::engine::general_purpose::STANDARD
            .decode(priv_key_str)
            .map_err(|e| NetworkError::Init(format!("Invalid private key encoding: {}", e)))?;

        // Parse as protobuf-encoded keypair
        let keypair = Keypair::from_protobuf_encoding(&key_bytes)
            .map_err(|e| NetworkError::Init(format!("Invalid keypair: {}", e)))?;

        Ok(keypair)
    }

    /// Check if daemon is running for a repository.
    pub fn is_running(repo_path: impl AsRef<Path>) -> bool {
        RepoLock::is_locked(repo_path)
    }

    /// Read API address from running daemon.
    pub fn read_api_addr(repo_path: impl AsRef<Path>) -> Option<String> {
        let api_file = repo_path.as_ref().join(API_FILE);
        fs::read_to_string(api_file).ok()
    }
}

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

    #[test]
    fn test_daemon_config_default() {
        let config = DaemonConfig::default();
        assert!(!config.offline);
        assert!(config.enable_mdns);
        assert_eq!(config.routing, "dht");
    }
}