regops 0.1.0

GitOps agent for localhost configuration management
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
127
128
129
130
131
132
133
134
135
136
137
138
139

use gix::{Repository, Url};
use std::path::Path;
use tracing::info;

pub fn git_clone(
    repository_url: Url,
    local_path: &str,
    branch: &str,
) -> Result<Repository, String> {
    let local_path = Path::new(local_path);

    let ref_name = format!("refs/heads/{}", branch);

    let mut prepare_clone = gix::prepare_clone(repository_url, local_path)
        .map_err(|details| format!("{}", details))?
        .with_ref_name(Some(ref_name.as_str()))
        .map_err(|details| format!("{}", details))?;

    let (mut prepare_checkout, _) = prepare_clone
        .fetch_then_checkout(gix::progress::Discard, &gix::interrupt::IS_INTERRUPTED)
        .map_err(|details| format!("{}", details))?;

    let (repo, _) = prepare_checkout
        .main_worktree(gix::progress::Discard, &gix::interrupt::IS_INTERRUPTED)
        .map_err(|details| format!("{}", details))?;

    let head: String = match repo.head_commit() {
        Ok(commit) => commit.id().to_string(),
        Err(_details) => "unknown".to_string(),
    };

    info!(head, "Initial cloning done");

    Ok(repo)
}

pub fn git_pull(local_path: &str) -> Result<(), String> {
    // Open the existing repository
    let repo = gix::open(local_path).map_err(|details| format!("{}", details))?;

    // Get current HEAD and find the active local branch name
    let head = repo.head().map_err(|details| format!("{}", details))?;
    let local_branch_ref = head
        .referent_name()
        .ok_or("Repository is in a detached HEAD state")?;

    let branch_short_name = local_branch_ref
        .as_bstr()
        .strip_prefix(b"refs/heads/")
        .ok_or("HEAD does not point to a local branch under refs/heads/")?;
    let branch_name_str =
        std::str::from_utf8(branch_short_name).map_err(|details| format!("{}", details))?;

    // Determine the remote and tracking branch using Git config mapping
    // Falls back to "origin" and the current branch name if no upstream is explicitly set
    let (remote_name, remote_branch_name) = repo
        .branch_remote_ref_name(local_branch_ref, gix::remote::Direction::Fetch)
        .and_then(|remote_ref| {
            // Parse remote name and branch from the tracking reference if available
            // e.g., refs/remotes/origin/main -> ("origin", "main")
            let name_str = remote_ref.unwrap().to_string();
            if let Some(stripped) = name_str.strip_prefix("refs/remotes/") {
                let mut parts = stripped.splitn(2, '/');
                let r = parts.next()?;
                let b = parts.next()?;
                Some((r.to_string(), b.to_string()))
            } else {
                None
            }
        })
        .unwrap_or_else(|| ("origin".to_string(), branch_name_str.to_string()));

    // Connect and fetch from the detected remote
    let remote = repo
        .find_remote(&remote_name)
        .map_err(|details| format!("{}", details))?;

    remote
        .connect(gix::remote::Direction::Fetch)
        .map_err(|details| format!("{}", details))?
        .prepare_fetch(gix::progress::Discard, Default::default())
        .map_err(|details| format!("{}", details))?
        .receive(gix::progress::Discard, &gix::interrupt::IS_INTERRUPTED)
        .map_err(|details| format!("{}", details))?;

    // Resolve the remote-tracking reference
    let remote_ref_name = format!("refs/remotes/{}/{}", remote_name, remote_branch_name);
    let mut remote_ref = repo
        .find_reference(&remote_ref_name)
        .map_err(|details| format!("{}", details))?;
    let target_commit_id = remote_ref
        .peel_to_id()
        .map_err(|details| format!("{}", details))?;

    // Update local branch reference (Fast-forward)
    let mut local_ref = repo
        .find_reference(local_branch_ref.as_bstr())
        .map_err(|details| format!("{}", details))?;
    local_ref
        .set_target_id(target_commit_id.detach(), "gix auto-pull: Fast-forward")
        .map_err(|details| format!("{}", details))?;

    // Update index and check out files into the working directory
    let commit = target_commit_id
        .object()
        .map_err(|details| format!("{}", details))?
        .peel_to_commit()
        .map_err(|details| format!("{}", details))?;
    let tree_id = commit.tree_id().map_err(|details| format!("{}", details))?;

    let mut index = repo
        .index_from_tree(&tree_id)
        .map_err(|details| format!("{}", details))?;
    index
        .write(gix::index::write::Options::default())
        .map_err(|details| format!("{}", details))?;

    if let Some(workdir) = repo.workdir() {
        gix::worktree::state::checkout(
            &mut index,
            workdir,
            repo.objects.clone(),
            &gix::progress::Discard,
            &gix::progress::Discard,
            &Default::default(),
            Default::default(),
        )
        .map_err(|details| format!("{}", details))?;
    }

    let head: String = match repo.head_commit() {
        Ok(commit) => commit.id().to_string(),
        Err(_details) => "unknown".to_string(),
    };

    info!(head, "Git pull done");

    Ok(())
}