1use 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}