Skip to main content

interprex_github/
releases.rs

1//! Release and asset operations owned by the releases domain.
2//!
3//! Release metadata is normalized into the shared model. Downloads return
4//! Octocrab's response chunks directly. Uploads accept a declared length and a
5//! one-shot stream, use GitHub's upload host, and deliberately bypass request
6//! retries: a partially consumed stream cannot be replayed safely. A caller may
7//! retry the whole operation only by constructing a fresh stream.
8
9use async_trait::async_trait;
10use futures_util::TryStreamExt;
11use http::{Request, header};
12use http_body::Frame;
13use http_body_util::StreamBody;
14use interprex::{
15    AssetId, AssetStream, AssetStreamError, AssetUpload, NewRelease, ProviderError, Release,
16    ReleaseAsset, ReleaseId, ReleasesProvider, Repository, Result,
17};
18use octocrab::{FromResponse, OctoBody};
19use percent_encoding::{NON_ALPHANUMERIC, utf8_percent_encode};
20use serde::Deserialize;
21use serde_json::json;
22
23use crate::{GithubProvider, client::external};
24
25#[derive(Deserialize)]
26struct GithubRelease {
27    id: u64,
28    tag_name: String,
29    name: Option<String>,
30    body: Option<String>,
31    draft: bool,
32    prerelease: bool,
33    #[serde(default)]
34    assets: Vec<GithubAsset>,
35}
36
37#[derive(Deserialize)]
38struct GithubAsset {
39    id: u64,
40    name: String,
41    label: Option<String>,
42    size: i64,
43    browser_download_url: String,
44}
45
46fn normalize_asset(value: GithubAsset) -> Result<ReleaseAsset> {
47    Ok(ReleaseAsset {
48        id: AssetId::new(value.id).map_err(|error| ProviderError::Unrepresentable {
49            provider: "github",
50            fact: error.to_string(),
51        })?,
52        name: value.name,
53        label: value.label,
54        size: u64::try_from(value.size).map_err(|error| ProviderError::Unrepresentable {
55            provider: "github",
56            fact: error.to_string(),
57        })?,
58        download_url: value.browser_download_url,
59    })
60}
61
62fn normalize_release(value: GithubRelease) -> Result<Release> {
63    Ok(Release {
64        id: ReleaseId::new(value.id).map_err(|error| ProviderError::Unrepresentable {
65            provider: "github",
66            fact: error.to_string(),
67        })?,
68        tag: value.tag_name,
69        name: value.name,
70        body: value.body,
71        draft: value.draft,
72        prerelease: value.prerelease,
73        assets: value
74            .assets
75            .into_iter()
76            .map(normalize_asset)
77            .collect::<Result<_>>()?,
78    })
79}
80
81#[async_trait]
82impl ReleasesProvider for GithubProvider {
83    #[tracing::instrument(
84        name = "interprex.provider.releases.release_by_tag",
85        skip_all,
86        fields(interprex.provider.name = "github")
87    )]
88    async fn release_by_tag(&self, repository: &Repository, tag: &str) -> Result<Release> {
89        let response: GithubRelease = self
90            .user()?
91            .get(
92                format!("/repos/{repository}/releases/tags/{tag}"),
93                None::<&()>,
94            )
95            .await
96            .map_err(|error| {
97                crate::client::read_error(
98                    "read release by tag",
99                    format!("release {tag} in {repository}"),
100                    error,
101                )
102            })?;
103        normalize_release(response)
104    }
105
106    #[tracing::instrument(
107        name = "interprex.provider.releases.create_release",
108        skip_all,
109        fields(interprex.provider.name = "github")
110    )]
111    async fn create_release(
112        &self,
113        repository: &Repository,
114        release: &NewRelease,
115    ) -> Result<Release> {
116        let response: GithubRelease = self
117            .user()?
118            .post(
119                format!("/repos/{repository}/releases"),
120                Some(&json!({
121                    "tag_name": release.tag,
122                    "name": release.name,
123                    "body": release.body,
124                    "target_commitish": release.target,
125                    "draft": release.draft,
126                    "prerelease": release.prerelease,
127                })),
128            )
129            .await
130            .map_err(|error| external("create release", error))?;
131        normalize_release(response)
132    }
133
134    #[tracing::instrument(
135        name = "interprex.provider.releases.upload_asset",
136        skip_all,
137        fields(interprex.provider.name = "github")
138    )]
139    async fn upload_asset(
140        &self,
141        repository: &Repository,
142        release_id: ReleaseId,
143        name: &str,
144        label: Option<&str>,
145        upload: AssetUpload,
146    ) -> Result<ReleaseAsset> {
147        let handler = self.user()?.repos(repository.owner(), repository.name());
148        let releases = handler.releases();
149        let release = releases
150            .get(release_id.get())
151            .await
152            .map_err(|error| external("read release for asset upload", error))?;
153        let mut upload_url = format!(
154            "{}?name={}",
155            release.upload_url.replace("{?name,label}", ""),
156            utf8_percent_encode(name, NON_ALPHANUMERIC)
157        );
158        if let Some(label) = label {
159            upload_url.push_str("&label=");
160            upload_url.push_str(&utf8_percent_encode(label, NON_ALPHANUMERIC).to_string());
161        }
162        let (content_length, chunks) = upload.into_parts();
163        let frames = chunks.map_ok(Frame::data);
164        let request = Request::builder()
165            .method(http::Method::POST)
166            .uri(upload_url)
167            .header(header::CONTENT_TYPE, "application/octet-stream")
168            .header(header::CONTENT_LENGTH, content_length)
169            .body(OctoBody::new(StreamBody::new(frames)))
170            .map_err(|error| external("construct release asset upload", error))?;
171        let response = self
172            .streaming_user()?
173            .execute(request)
174            .await
175            .map_err(|error| external("upload release asset", error))?;
176        let response = octocrab::map_github_error(response)
177            .await
178            .map_err(|error| external("upload release asset", error))?;
179        let response = GithubAsset::from_response(response)
180            .await
181            .map_err(|error| external("decode release asset upload", error))?;
182        normalize_asset(response)
183    }
184
185    #[tracing::instrument(
186        name = "interprex.provider.releases.download_asset",
187        skip_all,
188        fields(interprex.provider.name = "github")
189    )]
190    async fn download_asset(
191        &self,
192        repository: &Repository,
193        asset_id: AssetId,
194    ) -> Result<AssetStream> {
195        let handler = self.user()?.repos(repository.owner(), repository.name());
196        let stream = handler
197            .release_assets()
198            .stream(asset_id.get())
199            .await
200            .map_err(|error| external("open release asset stream", error))?;
201        Ok(Box::pin(
202            stream.map_err(|error| AssetStreamError::new(error.to_string())),
203        ))
204    }
205}
206
207#[cfg(test)]
208mod tests {
209    use super::{GithubRelease, normalize_release};
210
211    #[test]
212    fn release_fixture_normalizes_assets() {
213        let response: GithubRelease =
214            serde_json::from_str(include_str!("../tests/fixtures/release.json")).expect("fixture");
215        let release = normalize_release(response).expect("normalizes");
216        assert_eq!(release.tag, "v0.1.0");
217        assert_eq!(release.assets[0].name, "interprex.tar.gz");
218    }
219}