foreman 1.7.0

Toolchain manager for simple binary tools
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

//! Slice of Gitlab's API that Foreman consumes.

use reqwest::{
    blocking::Client,
    header::{ACCEPT, USER_AGENT},
};
use serde::{Deserialize, Serialize};

use super::{Release, ReleaseAsset, ToolProviderImpl};
use crate::{
    auth_store::AuthStore,
    error::{ForemanError, ForemanResult},
    paths::ForemanPaths,
};
use url::Url;

#[derive(Debug, Default)]
pub struct GitlabProvider {
    paths: ForemanPaths,
}

impl GitlabProvider {
    pub fn new(paths: ForemanPaths) -> Self {
        Self { paths }
    }
}

impl ToolProviderImpl for GitlabProvider {
    fn get_releases(&self, repo: &str, _host: &Url) -> ForemanResult<Vec<Release>> {
        let client = Client::new();

        let url = format!(
            "https://gitlab.com/api/v4/projects/{}/releases",
            urlencoding::encode(repo)
        );
        let mut builder = client.get(&url).header(USER_AGENT, "Roblox/foreman");

        let auth_store = AuthStore::load(&self.paths.auth_store())?;
        if let Some(token) = &auth_store.gitlab() {
            builder = builder.header("PRIVATE-TOKEN", token);
        }

        log::debug!("Downloading gitlab releases for {}", repo);
        let response_body = builder
            .send()
            .map_err(ForemanError::request_failed)?
            .text()
            .map_err(ForemanError::request_failed)?;

        let releases: Vec<GitlabRelease> = serde_json::from_str(&response_body).map_err(|err| {
            ForemanError::unexpected_response_body(err.to_string(), response_body, url)
        })?;

        Ok(releases.into_iter().map(Into::into).collect())
    }

    fn download_asset(&self, url: &str) -> ForemanResult<Vec<u8>> {
        let client = Client::new();

        let mut builder = client
            .get(url)
            .header(USER_AGENT, "Roblox/foreman")
            // Setting `Accept` is required to make the GitLab API return the actual
            // release asset instead of JSON metadata about the release.
            .header(ACCEPT, "application/octet-stream");

        let auth_store = AuthStore::load(&self.paths.auth_store())?;
        if let Some(token) = &auth_store.gitlab() {
            builder = builder.header("PRIVATE-TOKEN", token);
        }

        log::debug!("Downloading release asset {}", url);
        let mut response = builder.send().map_err(ForemanError::request_failed)?;

        let mut output = Vec::new();
        response
            .copy_to(&mut output)
            .map_err(ForemanError::request_failed)?;
        Ok(output)
    }
}

#[derive(Debug, Serialize, Deserialize)]
struct GitlabRelease {
    pub name: String,
    pub tag_name: String,
    pub upcoming_release: bool,
    pub assets: ReleaseAssets,
}

#[derive(Debug, Serialize, Deserialize)]
struct ReleaseAssets {
    links: Vec<GitlabAsset>,
}

#[derive(Debug, Serialize, Deserialize)]
struct GitlabAsset {
    pub url: String,
    pub name: String,
}

impl From<GitlabRelease> for Release {
    fn from(release: GitlabRelease) -> Self {
        Release {
            tag_name: release.tag_name,
            prerelease: release.upcoming_release,
            assets: release.assets.links.into_iter().map(Into::into).collect(),
        }
    }
}

impl From<GitlabAsset> for ReleaseAsset {
    fn from(asset: GitlabAsset) -> Self {
        ReleaseAsset {
            url: asset.url,
            name: asset.name,
        }
    }
}