Skip to main content

hyprstream_p2p/
daemon.rs

1//! GitTorrent Daemon Server
2//!
3//! This module implements the gittorrentd daemon that provides:
4//! - Repository hosting and announcement
5//! - P2P networking and discovery
6//! - XET chunk distribution
7//! - Git protocol serving
8
9use crate::service::{GitTorrentConfig, GitTorrentService};
10use crate::{Error, Result};
11
12use serde::{Deserialize, Serialize};
13use std::collections::HashMap;
14use std::path::{Path, PathBuf};
15use std::sync::Arc;
16use tokio::net::TcpListener;
17use tokio::sync::RwLock;
18
19/// GitTorrent daemon configuration
20#[derive(Debug, Clone, Serialize, Deserialize)]
21pub struct DaemonConfig {
22    /// GitTorrent service configuration
23    pub service: GitTorrentConfig,
24    /// Hosted repositories directory
25    pub repositories_dir: PathBuf,
26    /// Maximum number of hosted repositories
27    pub max_repositories: usize,
28    /// Enable Git protocol server
29    pub enable_git_server: bool,
30    /// Git protocol port
31    pub git_port: u16,
32}
33
34impl Default for DaemonConfig {
35    fn default() -> Self {
36        Self {
37            service: GitTorrentConfig::default(),
38            repositories_dir: dirs::cache_dir()
39                .unwrap_or_else(|| PathBuf::from("."))
40                .join("gittorrent")
41                .join("repositories"),
42            max_repositories: 100,
43            enable_git_server: true,
44            git_port: 9418, // Standard Git protocol port
45        }
46    }
47}
48
49/// Repository information for hosting
50#[derive(Debug, Clone, Serialize, Deserialize)]
51pub struct HostedRepository {
52    /// Repository name/identifier
53    pub name: String,
54    /// Local path to repository
55    pub path: PathBuf,
56    /// Repository metadata
57    pub description: Option<String>,
58    /// Repository size in bytes
59    pub size: u64,
60    /// Last announced timestamp
61    pub last_announced: u64,
62    /// Number of active peers
63    pub peer_count: usize,
64}
65
66/// GitTorrent daemon server
67pub struct GitTorrentDaemon {
68    /// GitTorrent service instance
69    service: Arc<GitTorrentService>,
70    /// Daemon configuration
71    config: DaemonConfig,
72    /// Hosted repositories
73    repositories: Arc<RwLock<HashMap<String, HostedRepository>>>,
74    /// Git protocol listener
75    git_listener: Option<TcpListener>,
76}
77
78impl GitTorrentDaemon {
79    /// Create a new GitTorrent daemon
80    pub async fn new(config: DaemonConfig) -> Result<Self> {
81        // Create repositories directory
82        tokio::fs::create_dir_all(&config.repositories_dir)
83            .await
84            .map_err(Error::from)?;
85
86        // Initialize GitTorrent service
87        let service = Arc::new(GitTorrentService::new(config.service.clone()).await?);
88
89        // Initialize Git protocol listener if enabled
90        let git_listener =
91            if config.enable_git_server {
92                let addr = format!("{}:{}", config.service.bind_address, config.git_port);
93                Some(TcpListener::bind(&addr).await.map_err(|e| {
94                    Error::other(format!("Failed to bind Git server to {addr}: {e}"))
95                })?)
96            } else {
97                None
98            };
99
100        Ok(Self {
101            service,
102            config,
103            repositories: Arc::new(RwLock::new(HashMap::new())),
104            git_listener,
105        })
106    }
107
108    /// Run the daemon server
109    pub async fn run(&self) -> Result<()> {
110        tracing::info!("GitTorrent daemon starting...");
111        tracing::info!(
112            "Repositories directory: {}",
113            self.config.repositories_dir.display()
114        );
115        tracing::info!(
116            "Service bind address: {}:{}",
117            self.config.service.bind_address,
118            self.config.service.bind_port
119        );
120
121        // Scan for existing repositories
122        self.scan_repositories().await?;
123
124        // Start Git protocol server if enabled
125        if let Some(ref listener) = self.git_listener {
126            let _service = Arc::clone(&self.service);
127            let repositories = Arc::clone(&self.repositories);
128            let listener_addr = listener.local_addr().map_err(Error::from)?;
129
130            tokio::spawn(async move {
131                // Note: In a real implementation, we'd need to pass the listener properly
132                // For now, just log that the server would be started
133                tracing::info!("Git protocol server would listen on: {}", listener_addr);
134                tracing::info!(
135                    "Git server task started with {} repositories",
136                    repositories.read().await.len()
137                );
138            });
139
140            tracing::info!(
141                "Git protocol server listening on port {}",
142                self.config.git_port
143            );
144        }
145
146        // Start periodic announcement of repositories
147        let service = Arc::clone(&self.service);
148        let repositories = Arc::clone(&self.repositories);
149
150        tokio::spawn(async move {
151            Self::run_announcement_loop(service, repositories).await;
152        });
153
154        // Keep the daemon running
155        tracing::info!("GitTorrent daemon is ready");
156
157        // In a real implementation, this would handle shutdown signals
158        loop {
159            tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;
160            tracing::debug!("Daemon heartbeat");
161        }
162    }
163
164    /// Scan repositories directory for existing repositories
165    async fn scan_repositories(&self) -> Result<()> {
166        let mut entries = tokio::fs::read_dir(&self.config.repositories_dir)
167            .await
168            .map_err(Error::from)?;
169
170        let mut repositories = self.repositories.write().await;
171
172        while let Some(entry) = entries.next_entry().await.map_err(Error::from)? {
173            let path = entry.path();
174
175            if path.is_dir() {
176                // Check if it's a Git repository
177                if path.join(".git").exists() || path.join("objects").exists() {
178                    let name = path
179                        .file_name()
180                        .and_then(|n| n.to_str())
181                        .unwrap_or("unknown")
182                        .to_owned();
183
184                    let size = self.calculate_repository_size(&path).await?;
185
186                    let hosted_repo = HostedRepository {
187                        name: name.clone(),
188                        path: path.clone(),
189                        description: None,
190                        size,
191                        last_announced: 0,
192                        peer_count: 0,
193                    };
194
195                    repositories.insert(name.clone(), hosted_repo);
196                    tracing::info!("Found repository: {} at {}", name, path.display());
197
198                    // Announce repository to P2P network
199                    if let Err(e) = self.service.announce_repository(&path).await {
200                        tracing::warn!("Failed to announce repository {}: {}", name, e);
201                    }
202                }
203            }
204        }
205
206        tracing::info!("Scanned {} repositories", repositories.len());
207        Ok(())
208    }
209
210    /// Calculate repository size
211    async fn calculate_repository_size(&self, repo_path: &Path) -> Result<u64> {
212        let mut total_size = 0;
213
214        let mut entries = tokio::fs::read_dir(repo_path).await.map_err(Error::from)?;
215
216        while let Some(entry) = entries.next_entry().await.map_err(Error::from)? {
217            let metadata = entry.metadata().await.map_err(Error::from)?;
218            if metadata.is_file() {
219                total_size += metadata.len();
220            }
221        }
222
223        Ok(total_size)
224    }
225
226    /// Run periodic announcement loop
227    async fn run_announcement_loop(
228        service: Arc<GitTorrentService>,
229        repositories: Arc<RwLock<HashMap<String, HostedRepository>>>,
230    ) {
231        let mut interval = tokio::time::interval(tokio::time::Duration::from_secs(300)); // 5 minutes
232
233        loop {
234            interval.tick().await;
235
236            let repos = repositories.read().await;
237            for (name, repo) in repos.iter() {
238                if let Err(e) = service.announce_repository(&repo.path).await {
239                    tracing::warn!("Failed to announce repository {}: {}", name, e);
240                } else {
241                    tracing::debug!("Announced repository: {}", name);
242                }
243            }
244
245            tracing::debug!(
246                "Completed announcement cycle for {} repositories",
247                repos.len()
248            );
249        }
250    }
251
252    /// Add a new repository to hosting
253    pub async fn add_repository(&self, name: String, path: PathBuf) -> Result<()> {
254        if !path.exists() {
255            return Err(Error::not_found(format!(
256                "Repository path does not exist: {}",
257                path.display()
258            )));
259        }
260
261        let size = self.calculate_repository_size(&path).await?;
262
263        let hosted_repo = HostedRepository {
264            name: name.clone(),
265            path: path.clone(),
266            description: None,
267            size,
268            last_announced: 0,
269            peer_count: 0,
270        };
271
272        let mut repositories = self.repositories.write().await;
273        repositories.insert(name.clone(), hosted_repo);
274
275        // Announce to P2P network
276        self.service.announce_repository(&path).await?;
277
278        tracing::info!("Added repository: {} at {}", name, path.display());
279        Ok(())
280    }
281
282    /// Get list of hosted repositories
283    pub async fn list_repositories(&self) -> HashMap<String, HostedRepository> {
284        self.repositories.read().await.clone()
285    }
286
287    /// Get daemon statistics
288    pub async fn get_stats(&self) -> DaemonStats {
289        let repositories = self.repositories.read().await;
290        let total_size: u64 = repositories.values().map(|r| r.size).sum();
291        let total_peers: usize = repositories.values().map(|r| r.peer_count).sum();
292
293        DaemonStats {
294            repository_count: repositories.len(),
295            total_size,
296            total_peers,
297            uptime_seconds: 0, // TODO: Track actual uptime
298        }
299    }
300}
301
302/// Daemon statistics
303#[derive(Debug, Serialize, Deserialize)]
304pub struct DaemonStats {
305    pub repository_count: usize,
306    pub total_size: u64,
307    pub total_peers: usize,
308    pub uptime_seconds: u64,
309}
310
311/// Entry point for gittorrentd binary
312pub async fn run_daemon(config: DaemonConfig) -> Result<()> {
313    let daemon = GitTorrentDaemon::new(config).await?;
314    daemon.run().await
315}
316
317#[cfg(test)]
318mod tests {
319    use super::*;
320    use tempfile::TempDir;
321
322    #[tokio::test]
323    async fn test_daemon_creation() -> crate::error::Result<()> {
324        let temp_dir = TempDir::new()?;
325        let config = DaemonConfig {
326            repositories_dir: temp_dir.path().to_path_buf(),
327            enable_git_server: false, // Disable for testing
328            ..Default::default()
329        };
330
331        let daemon = GitTorrentDaemon::new(config).await?;
332        let stats = daemon.get_stats().await;
333        assert_eq!(stats.repository_count, 0);
334        Ok(())
335    }
336
337    #[tokio::test]
338    async fn test_repository_management() -> crate::error::Result<()> {
339        let temp_dir = TempDir::new()?;
340        let repo_dir = temp_dir.path().join("test-repo");
341
342        // Create a proper Git repository using git2
343        git2::Repository::init(&repo_dir)?;
344        tokio::fs::write(repo_dir.join("README.md"), "# Test Repository").await?;
345
346        let config = DaemonConfig {
347            repositories_dir: temp_dir.path().to_path_buf(),
348            enable_git_server: false,
349            ..Default::default()
350        };
351
352        let daemon = GitTorrentDaemon::new(config).await?;
353
354        // Add repository
355        daemon
356            .add_repository("test-repo".to_owned(), repo_dir)
357            .await?;
358
359        // Check it was added
360        let repos = daemon.list_repositories().await;
361        assert_eq!(repos.len(), 1);
362        assert!(repos.contains_key("test-repo"));
363        Ok(())
364    }
365}