gitbackup 0.2.6

Backup all your git repositories with a single command
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

use crate::types::GenericRepository;
use crate::types::Provider;
use anyhow::{Context, Result};
use git2::build::CheckoutBuilder;
use git2::{Repository as Git, Repository};
use std::path::{Path, PathBuf};
use std::time::Duration;

pub fn sync_repositories(
    backup_path: &Path,
    provider: &Provider,
    repositories: &[impl GenericRepository],
) {
    println!("Found {:#?} repositories", &repositories.len());

    for r in repositories {
        if let Err(e) = sync_repository(backup_path, provider, r) {
            eprintln!(
                "Unable to sync repository {} with error {e:?}",
                &r.full_name()
            );
        }

        std::thread::sleep(Duration::from_millis(1000));
    }
}

fn sync_repository(
    backup_path: &Path,
    provider: &Provider,
    repository: &impl GenericRepository,
) -> Result<()> {
    let repository_directory = format!(
        "{}-{}",
        provider.host,
        &repository.full_name().replace('/', "-")
    );
    let path = backup_path.join(repository_directory);

    if let Ok(git) = Git::open(&path) {
        pull(&git, &path, provider, repository)?;
    } else {
        let git_url = format!(
            "https://{}:{}@{}/{}.git",
            &provider.username,
            &provider.token,
            &provider.host,
            &repository.full_name()
        );

        clone(&git_url, &path, provider, repository)?;
    };

    Ok(())
}

fn pull(
    git: &Repository,
    path: &Path,
    provider: &Provider,
    repository: &impl GenericRepository,
) -> Result<()> {
    println!(
        "Syncing {}/{} to {}",
        &provider.host,
        &repository.full_name(),
        &path.display()
    );

    if git.is_empty()? {
        return Ok(());
    }

    git.find_remote("origin")?
        .fetch(&[&repository.default_branch()], None, None)?;

    let fetch_head = git.find_reference("FETCH_HEAD")?;
    let fetch_commit = git.reference_to_annotated_commit(&fetch_head)?;
    let analysis = git.merge_analysis(&[&fetch_commit])?;

    if analysis.0.is_fast_forward() {
        let refname = format!("refs/heads/{}", &repository.default_branch());
        let mut reference = git.find_reference(&refname)?;
        reference.set_target(fetch_commit.id(), "Fast-Forward")?;
        git.set_head(&refname)?;
        git.checkout_head(Some(CheckoutBuilder::default().force()))?;
    };

    Ok(())
}

fn clone(
    url: &str,
    path: &PathBuf,
    provider: &Provider,
    repository: &impl GenericRepository,
) -> Result<()> {
    println!(
        "Cloning {}/{} to {}",
        &provider.host,
        &repository.full_name(),
        &path.display()
    );

    Git::clone(url, path).with_context(|| {
        format!(
            "Unable to clone repository {} with url {}",
            &repository.full_name(),
            &url
        )
    })?;

    Ok(())
}