adnv 1.5.0

CLI that tracks, checks and auto-updates infrastructure dependency versions across Terraform, Helm, Docker, Git and npm
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

use chrono::DateTime;

use super::{ListOptions, Tag};
use crate::{Error, Result};

pub async fn list_tags(source: &url::Url, options: &ListOptions<'_>) -> Result<Vec<Tag>> {
    let tmp_dir = tempfile::TempDir::with_prefix("adnv").map_err(Error::TempDirectory)?;
    let repo = tokio::task::spawn_blocking({
        // Both `git+https://host/repo` and the bare `git://host/repo` reach
        // this backend, and libgit2 understands the latter as is.
        let url = source
            .as_str()
            .strip_prefix("git+")
            .unwrap_or(source.as_str())
            .to_string();
        let path = tmp_dir.path().to_path_buf();

        move || {
            git2::build::RepoBuilder::new()
                .bare(true)
                .clone(&url, &path)
        }
    })
    .await
    .map_err(|err| Error::io(std::io::Error::other(err), "Clone task panicked"))?
    .map_err(|err| {
        Error::git(
            err,
            format!(
                "Could not clone source repository from {:?}",
                source.as_str()
            ),
        )
    })?;

    let versions: Vec<_> = repo
        .tag_names(None)
        .map_err(|err| {
            Error::git(
                err,
                format!("Could not list tags from {:?}", source.as_str()),
            )
        })?
        .iter_bytes()
        .filter_map(|name| match String::from_utf8(name.to_vec()) {
            Ok(name) => Some(name),
            Err(err) => {
                tracing::warn!("Bad tag name: {err}");
                None
            }
        })
        .filter_map(|name| match get_tag(&repo, &name) {
            Ok(version) => Some(version),
            Err(err) => {
                tracing::warn!("{}", miette::Report::new(err));
                None
            }
        })
        .collect();

    Ok(options.filter_tags(versions))
}

fn get_tag(repo: &git2::Repository, name: &str) -> Result<Tag> {
    let reference = repo
        .resolve_reference_from_short_name(name)
        .map_err(|err| Error::git(err, format!("Could not find reference `{name}`")))?;

    if let Some(tagger) = reference
        .peel_to_tag()
        .ok()
        .and_then(|tag| tag.tagger().map(|tagger| tagger.to_owned()))
    {
        let time = git_time_to_chrono(tagger.when()).ok_or_else(|| {
            Error::git(
                git2::Error::from_str("Invalid time"),
                "Could not convert time",
            )
        })?;
        Ok(Tag::new(name, time))
    } else if let Ok(commit) = reference.peel_to_commit() {
        let time = git_time_to_chrono(commit.time()).ok_or_else(|| {
            Error::git(
                git2::Error::from_str("Invalid time"),
                "Could not convert time",
            )
        })?;
        Ok(Tag::new(name, time))
    } else {
        Err(Error::git(
            git2::Error::from_str("Bad reference"),
            "Could not resolve repository version",
        ))
    }
}

fn git_time_to_chrono(time: git2::Time) -> Option<DateTime<chrono::Utc>> {
    use chrono::{DateTime, FixedOffset, TimeZone, Utc};

    let timestamp = time.seconds();
    let dt = DateTime::<Utc>::from_timestamp(timestamp, 0)?;

    Some(
        FixedOffset::west_opt(time.offset_minutes() * 60)?
            .from_utc_datetime(&dt.naive_utc())
            .into(),
    )
}