1use crate::crypto::hash::sha256_git;
4use crate::{
5 types::{GitHash, GitRefs, ObjectFormat, Sha256Hash},
6 Error, Result,
7};
8use git2::{ObjectType, Oid, Repository};
9use std::collections::HashMap;
10use std::path::Path;
11
12pub fn is_exportable<P: AsRef<Path>>(repo_path: P) -> bool {
14 let repo_path = repo_path.as_ref();
15
16 let export_ok_paths = [
18 repo_path.join("git-daemon-export-ok"),
19 repo_path.join(".git/git-daemon-export-ok"),
20 ];
21
22 export_ok_paths.iter().any(|path| path.exists())
23}
24
25#[derive(Debug, Clone)]
27pub struct GitObject {
28 pub hash: Sha256Hash,
29 pub object_type: GitObjectType,
30 pub data: Vec<u8>,
31 pub size: usize,
32}
33
34#[derive(Debug, Clone, PartialEq, Eq, Hash)]
36pub enum GitObjectType {
37 Commit,
38 Tree,
39 Blob,
40 Tag,
41}
42
43impl From<ObjectType> for GitObjectType {
44 fn from(obj_type: ObjectType) -> Self {
45 match obj_type {
46 ObjectType::Commit => GitObjectType::Commit,
47 ObjectType::Tree => GitObjectType::Tree,
48 ObjectType::Tag => GitObjectType::Tag,
49 ObjectType::Blob | ObjectType::Any => GitObjectType::Blob,
51 }
52 }
53}
54
55pub async fn extract_objects(repo_path: &Path) -> Result<Vec<GitObject>> {
57 let repo = Repository::open(repo_path)?;
58 let mut objects = Vec::new();
59
60 let odb = repo.odb()?;
62
63 let mut object_ids = Vec::new();
65 odb.foreach(|oid| {
66 object_ids.push(*oid);
67 true })?;
69
70 for oid in object_ids {
72 if let Ok(obj) = odb.read(oid) {
73 let type_str = match obj.kind() {
75 ObjectType::Commit => "commit",
76 ObjectType::Tree => "tree",
77 ObjectType::Tag => "tag",
78 ObjectType::Blob | ObjectType::Any => "blob",
80 };
81
82 let mut git_format = Vec::new();
83 git_format.extend_from_slice(type_str.as_bytes());
84 git_format.push(b' ');
85 git_format.extend_from_slice(obj.len().to_string().as_bytes());
86 git_format.push(0); git_format.extend_from_slice(obj.data());
88
89 let hash = sha256_git(&git_format)?;
91
92 objects.push(GitObject {
93 hash,
94 object_type: obj.kind().into(),
95 data: git_format,
96 size: obj.len(),
97 });
98 }
99 }
100
101 tracing::info!("Extracted {} objects from repository", objects.len());
102 Ok(objects)
103}
104
105pub async fn extract_commit_objects(repo_path: &Path, commit_hash: &str) -> Result<Vec<GitObject>> {
107 let repo = Repository::open(repo_path)?;
108 let mut objects = Vec::new();
109 let mut processed = std::collections::HashSet::new();
110
111 let commit_oid = Oid::from_str(commit_hash)?;
113 let mut to_process = vec![commit_oid];
114
115 while let Some(oid) = to_process.pop() {
116 if processed.contains(&oid) {
117 continue;
118 }
119 processed.insert(oid);
120
121 if let Ok(obj) = repo.find_object(oid, None) {
123 let git_object = create_git_object(&repo, &obj)?;
125 objects.push(git_object);
126
127 match obj.kind() {
129 Some(ObjectType::Commit) => {
130 if let Some(commit) = obj.as_commit() {
131 to_process.push(commit.tree_id());
133 for parent in commit.parent_ids() {
135 to_process.push(parent);
136 }
137 }
138 }
139 Some(ObjectType::Tree) => {
140 if let Some(tree) = obj.as_tree() {
141 for entry in tree.iter() {
142 to_process.push(entry.id());
143 }
144 }
145 }
146 _ => {} }
148 }
149 }
150
151 tracing::info!(
152 "Extracted {} objects for commit {}",
153 objects.len(),
154 commit_hash
155 );
156 Ok(objects)
157}
158
159fn create_git_object(repo: &Repository, obj: &git2::Object<'_>) -> Result<GitObject> {
161 let odb = repo.odb()?;
162 let odb_obj = odb.read(obj.id())?;
163
164 let type_str = match obj.kind() {
166 Some(ObjectType::Commit) => "commit",
167 Some(ObjectType::Tree) => "tree",
168 Some(ObjectType::Tag) => "tag",
169 Some(ObjectType::Blob | ObjectType::Any) | None => "blob",
171 };
172
173 let mut git_format = Vec::new();
174 git_format.extend_from_slice(type_str.as_bytes());
175 git_format.push(b' ');
176 git_format.extend_from_slice(odb_obj.len().to_string().as_bytes());
177 git_format.push(0);
178 git_format.extend_from_slice(odb_obj.data());
179
180 let hash = sha256_git(&git_format)?;
181
182 Ok(GitObject {
183 hash,
184 object_type: obj.kind().unwrap_or(ObjectType::Blob).into(),
185 data: git_format,
186 size: odb_obj.len(),
187 })
188}
189
190#[derive(Debug, Clone)]
192pub struct CommitObject {
193 pub tree_hash: GitHash,
194 pub parent_hashes: Vec<GitHash>,
195 pub author: String,
196 pub committer: String,
197 pub message: String,
198}
199
200#[derive(Debug, Clone)]
202pub struct TreeEntry {
203 pub mode: TreeEntryMode,
204 pub name: String,
205 pub hash: GitHash,
206}
207
208#[derive(Debug, Clone, PartialEq)]
210pub enum TreeEntryMode {
211 File, Executable, Directory, Symlink, Gitlink, }
217
218#[derive(Debug, Clone)]
220pub struct TreeObject {
221 pub entries: Vec<TreeEntry>,
222}
223
224pub fn parse_commit_object(data: &[u8]) -> Result<CommitObject> {
226 let null_pos = data
228 .iter()
229 .position(|&b| b == 0)
230 .ok_or_else(|| Error::other("Invalid git object format"))?;
231
232 let header = std::str::from_utf8(&data[..null_pos])?;
233 let content = &data[null_pos + 1..];
234
235 if !header.starts_with("commit ") {
237 return Err(Error::other("Not a commit object"));
238 }
239
240 let content_str = std::str::from_utf8(content)?;
241 let mut tree_hash = None;
242 let mut parent_hashes = Vec::new();
243 let mut author = String::new();
244 let mut committer = String::new();
245 let mut message_start = None;
246
247 for (i, line) in content_str.lines().enumerate() {
248 if line.is_empty() {
249 message_start = Some(
251 content_str
252 .lines()
253 .skip(i + 1)
254 .collect::<Vec<_>>()
255 .join("\n"),
256 );
257 break;
258 }
259
260 if let Some(hash_str) = line.strip_prefix("tree ") {
261 tree_hash = Some(GitHash::from_hex(hash_str.trim())?);
263 } else if let Some(hash_str) = line.strip_prefix("parent ") {
264 parent_hashes.push(GitHash::from_hex(hash_str.trim())?);
265 } else if let Some(author_str) = line.strip_prefix("author ") {
266 author = author_str.to_owned();
267 } else if let Some(committer_str) = line.strip_prefix("committer ") {
268 committer = committer_str.to_owned();
269 }
270 }
271
272 Ok(CommitObject {
273 tree_hash: tree_hash.ok_or_else(|| Error::other("Commit missing tree reference"))?,
274 parent_hashes,
275 author,
276 committer,
277 message: message_start.unwrap_or_default(),
278 })
279}
280
281pub fn parse_tree_object(data: &[u8], format: ObjectFormat) -> Result<TreeObject> {
290 let null_pos = data
292 .iter()
293 .position(|&b| b == 0)
294 .ok_or_else(|| Error::other("Invalid git object format"))?;
295
296 let header = std::str::from_utf8(&data[..null_pos])?;
297 let mut content = &data[null_pos + 1..];
298
299 if !header.starts_with("tree ") {
301 return Err(Error::other("Not a tree object"));
302 }
303
304 let mut entries = Vec::new();
305
306 while !content.is_empty() {
307 let null_pos = content
309 .iter()
310 .position(|&b| b == 0)
311 .ok_or_else(|| Error::other("Invalid tree entry format"))?;
312
313 let entry_header = std::str::from_utf8(&content[..null_pos])?;
314 let space_pos = entry_header
315 .find(' ')
316 .ok_or_else(|| Error::other("Invalid tree entry header"))?;
317
318 let mode_str = &entry_header[..space_pos];
319 let name = &entry_header[space_pos + 1..];
320
321 let mode = match mode_str {
323 "040000" => TreeEntryMode::Directory,
324 "100644" => TreeEntryMode::File,
325 "100755" => TreeEntryMode::Executable,
326 "120000" => TreeEntryMode::Symlink,
327 "160000" => TreeEntryMode::Gitlink,
328 _ => return Err(Error::other(format!("Unknown tree entry mode: {mode_str}"))),
329 };
330
331 let hash_size = format.hash_len();
335 if content.len() < null_pos + 1 + hash_size {
336 return Err(Error::other("Tree entry missing hash"));
337 }
338
339 let hash_bytes = &content[null_pos + 1..null_pos + 1 + hash_size];
340 let hash_hex = hex::encode(hash_bytes);
341 let hash = GitHash::from_hex(&hash_hex)?;
342
343 entries.push(TreeEntry {
344 mode,
345 name: name.to_owned(),
346 hash,
347 });
348
349 content = &content[null_pos + 1 + hash_size..];
351 }
352
353 Ok(TreeObject { entries })
354}
355
356pub fn parse_blob_object(data: &[u8]) -> Result<Vec<u8>> {
358 let null_pos = data
360 .iter()
361 .position(|&b| b == 0)
362 .ok_or_else(|| Error::other("Invalid git object format"))?;
363
364 let header = std::str::from_utf8(&data[..null_pos])?;
365
366 if !header.starts_with("blob ") {
368 return Err(Error::other("Not a blob object"));
369 }
370
371 Ok(data[null_pos + 1..].to_vec())
373}
374
375pub fn parse_object_references(object_data: &[u8], format: ObjectFormat) -> Result<Vec<GitHash>> {
381 let null_pos = object_data
383 .iter()
384 .position(|&b| b == 0)
385 .ok_or_else(|| Error::other("Invalid git object format"))?;
386
387 let header = std::str::from_utf8(&object_data[..null_pos])?;
388
389 if header.starts_with("commit ") {
390 let commit = parse_commit_object(object_data)?;
391 let mut refs = vec![commit.tree_hash];
392 refs.extend(commit.parent_hashes);
393 Ok(refs)
394 } else if header.starts_with("tree ") {
395 let tree = parse_tree_object(object_data, format)?;
396 Ok(tree.entries.into_iter().map(|e| e.hash).collect())
397 } else {
398 Ok(Vec::new())
400 }
401}
402
403pub async fn write_objects(repo_path: &Path, objects: &[GitObject]) -> Result<()> {
405 let repo = Repository::open(repo_path)?;
406 let odb = repo.odb()?;
407
408 for obj in objects {
409 if let Some(null_pos) = obj.data.iter().position(|&b| b == 0) {
411 let header = &obj.data[..null_pos];
412 let content = &obj.data[null_pos + 1..];
413
414 if let Ok(header_str) = std::str::from_utf8(header) {
416 let parts: Vec<&str> = header_str.split(' ').collect();
417 if parts.len() == 2 {
418 let obj_type = match parts[0] {
419 "commit" => ObjectType::Commit,
420 "tree" => ObjectType::Tree,
421 "tag" => ObjectType::Tag,
422 _ => ObjectType::Blob,
424 };
425
426 let oid = odb.write(obj_type, content)?;
428 tracing::debug!("Wrote object {} as git object {}", obj.hash, oid);
429 }
430 }
431 }
432 }
433
434 Ok(())
435}
436
437pub fn oid_to_hash(oid: Oid) -> Result<GitHash> {
439 GitHash::from_hex(&oid.to_string())
442}
443
444pub fn hash_to_oid(hash: &GitHash) -> Result<Oid> {
447 match hash {
450 GitHash::Sha1(_) => Oid::from_str(&hash.to_hex())
451 .map_err(|e| Error::other(format!("Cannot convert hash to Oid: {e}"))),
452 GitHash::Sha256(_) => {
453 Err(Error::other("SHA256 Oids not yet supported by git2-rs"))
456 }
457 }
458}
459
460#[deprecated(note = "Use oid_to_hash instead - it supports both SHA1 and SHA256")]
462pub fn oid_to_sha256(oid: Oid) -> Result<Sha256Hash> {
463 let oid_str = oid.to_string();
464 if oid_str.len() == 64 {
465 Sha256Hash::new(oid_str)
466 } else {
467 Err(Error::other(
468 "SHA1 hashes are no longer supported, use SHA256",
469 ))
470 }
471}
472
473#[deprecated(note = "Use hash_to_oid instead - it supports GitHash enum")]
475pub fn sha256_to_oid(hash: &Sha256Hash) -> Result<Oid> {
476 Oid::from_str(hash.as_str()).map_err(|e| {
477 Error::other(format!(
478 "Cannot convert SHA256 to Oid (git2 limitation): {e}"
479 ))
480 })
481}
482
483pub async fn extract_git_refs(repo_path: &Path) -> Result<GitRefs> {
485 let repo = Repository::open(repo_path)?;
486 let mut refs_map = HashMap::new();
487
488 let refs = repo.references()?;
490 for reference in refs {
491 let reference = reference?;
492 if let Some(name) = reference.name() {
493 if let Some(target) = reference.target() {
494 let hash = oid_to_hash(target)?;
496 refs_map.insert(name.to_owned(), hash);
497 }
498 }
499 }
500
501 let head = repo.head()?;
503 let head_name = head.name().unwrap_or("refs/heads/main").to_owned();
504
505 let created_at = std::time::SystemTime::now()
507 .duration_since(std::time::UNIX_EPOCH)?
508 .as_secs();
509
510 Ok(GitRefs {
511 refs: refs_map,
512 head: head_name,
513 created_at,
514 })
515}
516
517#[cfg(test)]
518#[allow(clippy::unwrap_used, clippy::expect_used)]
519mod tests {
520 use super::*;
521 use git2::Repository;
522 use std::fs;
523 use tempfile::TempDir;
524
525 fn make_tree_object(name: &str, oid: &[u8]) -> Vec<u8> {
528 let mut content = Vec::new();
529 content.extend_from_slice(b"100644 ");
530 content.extend_from_slice(name.as_bytes());
531 content.push(0);
532 content.extend_from_slice(oid);
533
534 let mut object = format!("tree {}\0", content.len()).into_bytes();
535 object.extend_from_slice(&content);
536 object
537 }
538
539 #[test]
540 fn test_parse_tree_object_sha256_oid() {
541 let oid = [0xABu8; 32];
543 let object = make_tree_object("modern.txt", &oid);
544
545 let tree = parse_tree_object(&object, ObjectFormat::Sha256).unwrap();
546 assert_eq!(tree.entries.len(), 1);
547 let entry = &tree.entries[0];
548 assert_eq!(entry.name, "modern.txt");
549 assert_eq!(entry.hash, GitHash::Sha256(oid));
550 assert_eq!(entry.hash.to_hex(), hex::encode(oid));
551 }
552
553 #[test]
554 fn test_parse_tree_object_sha1_oid() {
555 let oid = [0x11u8; 20];
557 let object = make_tree_object("legacy.txt", &oid);
558
559 let tree = parse_tree_object(&object, ObjectFormat::Sha1).unwrap();
560 assert_eq!(tree.entries.len(), 1);
561 let entry = &tree.entries[0];
562 assert_eq!(entry.name, "legacy.txt");
563 assert_eq!(entry.hash, GitHash::Sha1(oid));
564 }
565
566 #[test]
567 fn test_parse_tree_object_sha256_with_sha1_width_is_wrong() {
568 let oid = [0xABu8; 32];
571 let object = make_tree_object("modern.txt", &oid);
572
573 if let Ok(tree) = parse_tree_object(&object, ObjectFormat::Sha1) {
577 assert_ne!(tree.entries[0].hash, GitHash::Sha256(oid));
578 }
579 }
580
581 #[test]
582 fn test_object_format_hash_len() {
583 assert_eq!(ObjectFormat::Sha1.hash_len(), 20);
584 assert_eq!(ObjectFormat::Sha256.hash_len(), 32);
585 assert_eq!(GitHash::Sha1([0u8; 20]).object_format(), ObjectFormat::Sha1);
586 assert_eq!(
587 GitHash::Sha256([0u8; 32]).object_format(),
588 ObjectFormat::Sha256
589 );
590 }
591
592 #[tokio::test]
593 async fn test_extract_objects() -> std::result::Result<(), Box<dyn std::error::Error>> {
594 let temp_dir = TempDir::new()?;
595
596 let repo = Repository::init(temp_dir.path())?;
598
599 let file_path = temp_dir.path().join("test.txt");
601 fs::write(&file_path, "Hello World")?;
602
603 let mut index = repo.index()?;
605 index.add_path(Path::new("test.txt"))?;
606 index.write()?;
607
608 let tree_id = index.write_tree()?;
609 let tree = repo.find_tree(tree_id)?;
610 let sig = git2::Signature::now("Test", "test@example.com")?;
611
612 repo.commit(Some("HEAD"), &sig, &sig, "Initial commit", &tree, &[])?;
613
614 let objects = extract_objects(temp_dir.path()).await?;
616
617 assert!(objects.len() >= 3);
619
620 let types: std::collections::HashSet<_> = objects.iter().map(|o| &o.object_type).collect();
622 assert!(types.contains(&GitObjectType::Blob));
623 assert!(types.contains(&GitObjectType::Tree));
624 assert!(types.contains(&GitObjectType::Commit));
625 Ok(())
626 }
627
628 #[test]
629 fn test_is_exportable() -> std::result::Result<(), Box<dyn std::error::Error>> {
630 let temp_dir = TempDir::new()?;
631
632 let repo = Repository::init(temp_dir.path())?;
634 drop(repo);
635
636 assert!(!is_exportable(temp_dir.path()));
638
639 let export_file = temp_dir.path().join(".git/git-daemon-export-ok");
641 fs::write(export_file, "")?;
642
643 assert!(is_exportable(temp_dir.path()));
645 Ok(())
646 }
647}