oci2git 0.2.5

A tool to convert OCI images to Git repositories
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use anyhow::{anyhow, Result};
use std::path::PathBuf;
use tempfile::TempDir;

use super::Source;
use crate::notifier::Notifier;

/// Extracts filename from a tar path and sanitizes it for Git branch naming
/// Removes file extension and sanitizes problematic characters
fn tar_to_branch(tar_path: &str) -> String {
    let path = PathBuf::from(tar_path);
    let filename = path
        .file_stem()
        .and_then(|name| name.to_str())
        .unwrap_or("tar-image");

    super::sanitize_branch_name(filename)
}

/// Tar implementation of the Source trait for pre-downloaded tarballs
pub struct TarSource;

impl TarSource {
    pub fn new() -> Result<Self> {
        Ok(Self)
    }
}

impl Source for TarSource {
    fn name(&self) -> &str {
        "tar"
    }

    fn get_image_tarball(
        &self,
        image_path: &str,
        notifier: &Notifier,
    ) -> Result<(PathBuf, Option<TempDir>)> {
        // For tar source, image_path is the path to the existing tarball
        let tarball_path = PathBuf::from(image_path);

        // Verify the tarball exists
        if !tarball_path.exists() {
            return Err(anyhow!(
                "Tarball file does not exist: {}",
                tarball_path.display()
            ));
        }

        // Check if it's a file
        if !tarball_path.is_file() {
            return Err(anyhow!("Path is not a file: {}", tarball_path.display()));
        }

        // Verify it's a tar file (just basic name check, could be improved)
        let extension = tarball_path
            .extension()
            .and_then(|ext| ext.to_str())
            .unwrap_or("");

        if extension != "tar" {
            notifier.info("Warning: File does not have .tar extension. Proceeding anyway, but this might not be a valid image tarball.");
        }

        // Just return the existing path - no temp dir needed for tar source
        Ok((tarball_path, None))
    }

    fn branch_name(&self, image_path: &str, os_arch: &str, image_digest: &str) -> String {
        let base_branch = tar_to_branch(image_path);
        if let Some(short_digest) = super::extract_short_digest(image_digest) {
            format!("{base_branch}#{os_arch}#{short_digest}")
        } else {
            // Fallback: use image_digest as-is if it doesn't have sha256: prefix
            format!("{base_branch}#{os_arch}#{image_digest}")
        }
    }
}

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

    #[test]
    fn test_tar_to_branch() {
        assert_eq!(tar_to_branch("/path/to/my-image.tar"), "my-image");
        assert_eq!(tar_to_branch("./nginx-latest.tar.gz"), "nginx-latest-tar");
        assert_eq!(tar_to_branch("ubuntu 20.04.tar"), "ubuntu-20-04");
        assert_eq!(tar_to_branch("my:app@v1.0.tar"), "my-app-v1-0");
        assert_eq!(tar_to_branch("hello world.tar"), "hello-world");
        assert_eq!(
            tar_to_branch("file with spaces & symbols!.tar"),
            "file-with-spaces-symbols"
        );
    }

    #[test]
    fn test_tar_source_branch_name() {
        let source = TarSource::new().unwrap();
        assert_eq!(
            source.branch_name(
                "/path/to/my-image.tar",
                "linux-amd64",
                "sha256:1234567890abcdef"
            ),
            "my-image#linux-amd64#1234567890ab"
        );
        assert_eq!(
            source.branch_name("nginx-latest.tar", "linux-arm64", "sha256:9876543210fedcba"),
            "nginx-latest#linux-arm64#9876543210fe"
        );
        assert_eq!(
            source.branch_name(
                "ubuntu 20.04.tar",
                "windows-amd64",
                "sha256:abcdef123456789"
            ),
            "ubuntu-20-04#windows-amd64#abcdef123456"
        );
        // Test fallback for digest without sha256: prefix
        assert_eq!(
            source.branch_name("ubuntu 20.04.tar", "linux-amd64", "abcdef123456789"),
            "ubuntu-20-04#linux-amd64#abcdef123456789"
        );
    }
}