eol-deployer 0.1.0

A tool for deploying new versions of traefik configs
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

pub struct GitClient;

impl GitClient {
    pub async fn clone_repository_to_versioned_path(
        &self,
        repo_url: &str,
        tag: &str,
        base_path: &str,
    ) -> Result<String, Box<dyn std::error::Error>> {
        let versioned_path = format!("{}/traefik-config-{}", base_path, tag);

        println!(
            "Cloning repository {} at tag {} to {}",
            repo_url, tag, versioned_path
        );

        // Remove existing directory if it exists
        if std::path::Path::new(&versioned_path).exists() {
            std::fs::remove_dir_all(&versioned_path)?;
        }

        // Create parent directory if it doesn't exist
        if let Some(parent) = std::path::Path::new(&versioned_path).parent() {
            std::fs::create_dir_all(parent)?;
        }

        // Clone the repository
        let output = std::process::Command::new("git")
            .args(&[
                "clone",
                "--depth",
                "1",
                "--branch",
                tag,
                repo_url,
                &versioned_path,
            ])
            .output()?;

        if !output.status.success() {
            return Err(format!(
                "Git clone failed: {}",
                String::from_utf8_lossy(&output.stderr)
            )
            .into());
        }

        println!(
            "Successfully cloned {} at tag {} to {}",
            repo_url, tag, versioned_path
        );
        Ok(versioned_path)
    }

    pub async fn fetch_latest(&self, repo_dir: &str) -> Result<(), Box<dyn std::error::Error>> {
        println!("Fetching latest changes in {}", repo_dir);

        let output = std::process::Command::new("git")
            .args(&["fetch", "--all"])
            .current_dir(repo_dir)
            .output()?;

        if !output.status.success() {
            return Err(format!(
                "Git fetch failed: {}",
                String::from_utf8_lossy(&output.stderr)
            )
            .into());
        }

        Ok(())
    }

    pub async fn checkout_tag(
        &self,
        repo_dir: &str,
        tag: &str,
    ) -> Result<(), Box<dyn std::error::Error>> {
        println!("Checking out tag {} in {}", tag, repo_dir);

        let output = std::process::Command::new("git")
            .args(&["checkout", tag])
            .current_dir(repo_dir)
            .output()?;

        if !output.status.success() {
            return Err(format!(
                "Git checkout failed: {}",
                String::from_utf8_lossy(&output.stderr)
            )
            .into());
        }

        println!("Successfully checked out tag {}", tag);
        Ok(())
    }
}