1use 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#[derive(Debug, Clone, Serialize, Deserialize)]
21pub struct DaemonConfig {
22 pub service: GitTorrentConfig,
24 pub repositories_dir: PathBuf,
26 pub max_repositories: usize,
28 pub enable_git_server: bool,
30 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, }
46 }
47}
48
49#[derive(Debug, Clone, Serialize, Deserialize)]
51pub struct HostedRepository {
52 pub name: String,
54 pub path: PathBuf,
56 pub description: Option<String>,
58 pub size: u64,
60 pub last_announced: u64,
62 pub peer_count: usize,
64}
65
66pub struct GitTorrentDaemon {
68 service: Arc<GitTorrentService>,
70 config: DaemonConfig,
72 repositories: Arc<RwLock<HashMap<String, HostedRepository>>>,
74 git_listener: Option<TcpListener>,
76}
77
78impl GitTorrentDaemon {
79 pub async fn new(config: DaemonConfig) -> Result<Self> {
81 tokio::fs::create_dir_all(&config.repositories_dir)
83 .await
84 .map_err(Error::from)?;
85
86 let service = Arc::new(GitTorrentService::new(config.service.clone()).await?);
88
89 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 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 self.scan_repositories().await?;
123
124 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 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 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 tracing::info!("GitTorrent daemon is ready");
156
157 loop {
159 tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;
160 tracing::debug!("Daemon heartbeat");
161 }
162 }
163
164 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 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 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 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 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)); 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 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 self.service.announce_repository(&path).await?;
277
278 tracing::info!("Added repository: {} at {}", name, path.display());
279 Ok(())
280 }
281
282 pub async fn list_repositories(&self) -> HashMap<String, HostedRepository> {
284 self.repositories.read().await.clone()
285 }
286
287 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, }
299 }
300}
301
302#[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
311pub 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, ..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 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 daemon
356 .add_repository("test-repo".to_owned(), repo_dir)
357 .await?;
358
359 let repos = daemon.list_repositories().await;
361 assert_eq!(repos.len(), 1);
362 assert!(repos.contains_key("test-repo"));
363 Ok(())
364 }
365}