rust_realease/src/gitea.rs

459 lines
17 KiB
Rust

use crate::error::Error;
use reqwest::{
blocking::{
multipart::{Form, Part},
Client,
},
header::{HeaderMap, HeaderValue, AUTHORIZATION},
Method, StatusCode,
};
use serde::Deserialize;
use serde_json::{json, Value};
use std::{env, fs::File, path::Path, time::Duration};
#[derive(Debug, Deserialize)]
pub struct RemoteRelease {
pub id: u64,
#[serde(default)]
pub draft: bool,
}
#[derive(Debug, Deserialize)]
struct Asset {
id: u64,
name: String,
}
pub struct Gitea {
client: Client,
base: String,
}
impl Gitea {
pub fn new(repository: &str, token_env: &str) -> Result<Self, Error> {
if !repository.starts_with("https://") {
return Err(Error(
"Authenticated Gitea publishing requires HTTPS.".into(),
));
}
let token = env::var(token_env)
.ok()
.filter(|s| !s.is_empty())
.ok_or_else(|| Error(format!("Set {token_env} before publishing.")))?;
Self::with_token(repository, &token)
}
fn with_token(repository: &str, token: &str) -> Result<Self, Error> {
let parsed = url::Url::parse(repository)
.map_err(|_| Error("Invalid release repository URL.".into()))?;
let parts: Vec<_> = parsed
.path_segments()
.ok_or_else(|| Error("Repository URL must end in owner/repository.".into()))?
.filter(|part| !part.is_empty())
.collect();
if parts.len() < 2 {
return Err(Error("Repository URL must end in owner/repository.".into()));
}
let prefix = parts[..parts.len() - 2].join("/");
let owner = parts[parts.len() - 2];
let name = parts[parts.len() - 1];
let origin = parsed.origin().ascii_serialization();
let base = if prefix.is_empty() {
format!("{origin}/api/v1/repos/{owner}/{name}")
} else {
format!("{origin}/{prefix}/api/v1/repos/{owner}/{name}")
};
let mut headers = HeaderMap::new();
headers.insert(
AUTHORIZATION,
HeaderValue::from_str(&format!("token {token}"))
.map_err(|_| Error("Invalid Gitea token value.".into()))?,
);
let client = Client::builder()
.default_headers(headers)
.user_agent("rust_realease/0.1")
.timeout(Duration::from_secs(120))
.redirect(reqwest::redirect::Policy::none())
.build()
.map_err(|_| Error("Cannot initialize Gitea HTTP client.".into()))?;
Ok(Self { client, base })
}
fn request(
&self,
method: Method,
path: &str,
body: Option<Value>,
missing_ok: bool,
) -> Result<Option<Value>, Error> {
let url = format!("{}{path}", self.base);
let mut request = self.client.request(method.clone(), &url);
if let Some(body) = body {
request = request.json(&body);
}
let response = request
.send()
.map_err(|_| Error(format!("Gitea {method} {path}: connection failed.")))?;
if missing_ok && response.status() == StatusCode::NOT_FOUND {
return Ok(None);
}
if !response.status().is_success() {
return Err(Error(format!(
"Gitea {method} {path}: HTTP {}.",
response.status().as_u16()
)));
}
let bytes = response
.bytes()
.map_err(|_| Error(format!("Gitea {method} {path}: response failed.")))?;
if bytes.is_empty() {
return Ok(Some(Value::Null));
}
serde_json::from_slice(&bytes)
.map(Some)
.map_err(|_| Error(format!("Gitea {method} {path}: invalid JSON response.")))
}
pub fn ensure_release(
&self,
tag: &str,
commit: &str,
draft: bool,
prerelease: bool,
) -> Result<RemoteRelease, Error> {
let encoded = encode(tag);
let remote = self
.request(Method::GET, &format!("/tags/{encoded}"), None, true)?
.ok_or_else(|| {
Error(format!(
"Remote tag {tag:?} is missing. Push the tag explicitly before publishing."
))
})?;
if remote.pointer("/commit/sha").and_then(Value::as_str) != Some(commit) {
return Err(Error(
"Remote tag commit differs from the checkout; refusing publication.".into(),
));
}
let release = if let Some(existing) = self.request(
Method::GET,
&format!("/releases/tags/{encoded}"),
None,
true,
)? {
existing
} else {
self.request(Method::POST, "/releases", Some(json!({"tag_name": tag, "name": tag, "target_commitish": commit, "draft": draft, "prerelease": prerelease})), false)?
.ok_or_else(|| Error("Gitea release creation returned no response.".into()))?
};
serde_json::from_value(release)
.map_err(|_| Error("Gitea release response is missing id or draft state.".into()))
}
fn assets(&self, release_id: u64) -> Result<Vec<Asset>, Error> {
let response = self
.request(
Method::GET,
&format!("/releases/{release_id}/assets"),
None,
false,
)?
.ok_or_else(|| Error("Gitea assets response is empty.".into()))?;
serde_json::from_value(response)
.map_err(|_| Error("Gitea assets response is invalid.".into()))
}
pub fn upload(&self, release_id: u64, paths: &[&Path], replace: bool) -> Result<(), Error> {
let existing = self.assets(release_id)?;
let names: Vec<_> = paths
.iter()
.map(|p| {
p.file_name()
.and_then(|s| s.to_str())
.ok_or_else(|| Error("Invalid upload filename.".into()))
})
.collect::<Result<_, _>>()?;
let collisions: Vec<_> = existing
.iter()
.filter(|asset| names.contains(&asset.name.as_str()))
.collect();
if !collisions.is_empty() && !replace {
return Err(Error(format!("Release assets already exist: {}. Use --replace-assets to replace them explicitly.", collisions.iter().map(|a| a.name.as_str()).collect::<Vec<_>>().join(", "))));
}
for (path, name) in paths.iter().zip(names.iter()) {
for asset in collisions.iter().filter(|asset| asset.name == *name) {
self.request(
Method::DELETE,
&format!("/releases/{release_id}/assets/{}", asset.id),
None,
false,
)?;
}
let input = File::open(path)
.map_err(|e| Error(format!("cannot open asset {}: {e}", path.display())))?;
let size = input
.metadata()
.map_err(|e| Error(format!("cannot inspect asset {}: {e}", path.display())))?
.len();
let part = Part::reader_with_length(input, size)
.file_name((*name).to_owned())
.mime_str("application/octet-stream")
.map_err(|_| Error("Invalid upload MIME type.".into()))?;
let mut url = url::Url::parse(&format!("{}/releases/{release_id}/assets", self.base))
.map_err(|_| Error("Invalid Gitea upload URL.".into()))?;
url.query_pairs_mut().append_pair("name", name);
let response = self
.client
.post(url)
.multipart(Form::new().part("attachment", part))
.send()
.map_err(|_| {
Error(format!(
"Gitea POST /releases/{release_id}/assets: connection failed."
))
})?;
if !response.status().is_success() {
return Err(Error(format!(
"Gitea POST /releases/{release_id}/assets: HTTP {}.",
response.status().as_u16()
)));
}
println!("Uploaded {name}");
}
Ok(())
}
}
fn encode(segment: &str) -> String {
url::form_urlencoded::byte_serialize(segment.as_bytes()).collect()
}
#[cfg(test)]
mod tests {
use super::*;
use std::{
io::{Read, Write},
net::TcpListener,
thread,
time::Duration,
};
struct Reply {
method: &'static str,
path: &'static str,
status: u16,
body: &'static str,
}
fn server(replies: Vec<Reply>) -> (String, thread::JoinHandle<Vec<String>>) {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let address = format!("http://{}", listener.local_addr().unwrap());
let handle = thread::spawn(move || {
let mut requests = Vec::new();
for reply in replies {
let (mut stream, _) = listener.accept().unwrap();
stream
.set_read_timeout(Some(Duration::from_secs(5)))
.unwrap();
let mut bytes = Vec::new();
let mut buffer = [0_u8; 8192];
let header_end = loop {
let n = stream.read(&mut buffer).unwrap();
assert!(n > 0, "client closed before headers");
bytes.extend_from_slice(&buffer[..n]);
if let Some(index) = bytes.windows(4).position(|w| w == b"\r\n\r\n") {
break index + 4;
}
assert!(bytes.len() < 64 * 1024);
};
let headers = String::from_utf8_lossy(&bytes[..header_end]).to_string();
assert!(
headers
.lines()
.any(|line| line.eq_ignore_ascii_case("authorization: token test-token")),
"authenticated Gitea request lacked the configured token"
);
let first = headers.lines().next().unwrap().to_owned();
assert!(
first.starts_with(&format!("{} {} ", reply.method, reply.path)),
"{first}"
);
let length = headers
.lines()
.find_map(|line| {
line.to_ascii_lowercase()
.strip_prefix("content-length: ")
.and_then(|v| v.trim().parse::<usize>().ok())
})
.unwrap_or(0);
while bytes.len() < header_end + length {
let n = stream.read(&mut buffer).unwrap();
assert!(n > 0, "client closed before body");
bytes.extend_from_slice(&buffer[..n]);
}
requests.push(first);
let reason = if reply.status == 200 {
"OK"
} else if reply.status == 201 {
"Created"
} else if reply.status == 204 {
"No Content"
} else if reply.status == 404 {
"Not Found"
} else {
"Unauthorized"
};
write!(stream, "HTTP/1.1 {} {}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}", reply.status, reason, reply.body.len(), reply.body).unwrap();
}
requests
});
(address, handle)
}
#[test]
fn creates_or_reuses_release_after_remote_tag_check() {
let base = "/gitea/api/v1/repos/team/demo";
let (host, handle) = server(vec![
Reply {
method: "GET",
path: "/gitea/api/v1/repos/team/demo/tags/v0.1.0",
status: 200,
body: r#"{"commit":{"sha":"abc"}}"#,
},
Reply {
method: "GET",
path: "/gitea/api/v1/repos/team/demo/releases/tags/v0.1.0",
status: 404,
body: "{}",
},
Reply {
method: "POST",
path: "/gitea/api/v1/repos/team/demo/releases",
status: 201,
body: r#"{"id":7,"draft":false}"#,
},
]);
let api = Gitea::with_token(&format!("{host}/gitea/team/demo"), "test-token").unwrap();
let release = api.ensure_release("v0.1.0", "abc", false, true).unwrap();
assert_eq!(release.id, 7);
assert_eq!(handle.join().unwrap().len(), 3);
let (host, handle) = server(vec![
Reply {
method: "GET",
path: "/gitea/api/v1/repos/team/demo/tags/v0.1.0",
status: 200,
body: r#"{"commit":{"sha":"abc"}}"#,
},
Reply {
method: "GET",
path: "/gitea/api/v1/repos/team/demo/releases/tags/v0.1.0",
status: 200,
body: r#"{"id":9,"draft":true}"#,
},
]);
let api = Gitea::with_token(&format!("{host}/gitea/team/demo"), "test-token").unwrap();
assert_eq!(
api.ensure_release("v0.1.0", "abc", false, false)
.unwrap()
.id,
9
);
assert_eq!(handle.join().unwrap().len(), 2);
let _ = base;
}
#[test]
fn collisions_refuse_or_replace_only_matching_asset() {
let temp = tempfile::tempdir().unwrap();
let path = temp.path().join("one.tgz");
std::fs::write(&path, b"archive").unwrap();
let assets = r#"[{"id":3,"name":"one.tgz"},{"id":4,"name":"unrelated.tgz"}]"#;
let (host, handle) = server(vec![Reply {
method: "GET",
path: "/api/v1/repos/team/demo/releases/7/assets",
status: 200,
body: assets,
}]);
let api = Gitea::with_token(&format!("{host}/team/demo"), "test-token").unwrap();
assert!(api
.upload(7, &[&path], false)
.unwrap_err()
.to_string()
.contains("--replace-assets"));
assert_eq!(handle.join().unwrap().len(), 1);
let (host, handle) = server(vec![
Reply {
method: "GET",
path: "/api/v1/repos/team/demo/releases/7/assets",
status: 200,
body: assets,
},
Reply {
method: "DELETE",
path: "/api/v1/repos/team/demo/releases/7/assets/3",
status: 204,
body: "",
},
Reply {
method: "POST",
path: "/api/v1/repos/team/demo/releases/7/assets?name=one.tgz",
status: 201,
body: r#"{"id":5}"#,
},
]);
let api = Gitea::with_token(&format!("{host}/team/demo"), "test-token").unwrap();
api.upload(7, &[&path], true).unwrap();
assert_eq!(handle.join().unwrap().len(), 3);
}
#[test]
fn api_errors_do_not_echo_server_body_or_token() {
let (host, handle) = server(vec![Reply {
method: "GET",
path: "/api/v1/repos/team/demo/tags/v0.1.0",
status: 401,
body: "test-token",
}]);
let api = Gitea::with_token(&format!("{host}/team/demo"), "test-token").unwrap();
let error = api
.ensure_release("v0.1.0", "abc", false, false)
.unwrap_err()
.to_string();
assert!(error.contains("HTTP 401"));
assert!(!error.contains("test-token"));
handle.join().unwrap();
}
#[test]
fn missing_or_mismatched_remote_tag_stops_before_release_mutation() {
for (status, body, expected) in [
(404, "{}", "missing"),
(200, r#"{"commit":{"sha":"other"}}"#, "differs"),
] {
let (host, handle) = server(vec![Reply {
method: "GET",
path: "/api/v1/repos/team/demo/tags/v0.1.0",
status,
body,
}]);
let api = Gitea::with_token(&format!("{host}/team/demo"), "test-token").unwrap();
let error = api
.ensure_release("v0.1.0", "abc", false, false)
.unwrap_err()
.to_string();
assert!(error.contains(expected), "{error}");
assert_eq!(handle.join().unwrap().len(), 1);
}
}
#[test]
fn encodes_tag_and_requires_https() {
assert_eq!(encode("v1.0+build"), "v1.0%2Bbuild");
assert!(Gitea::new("http://example.com/team/demo", "GITEA_TOKEN")
.err()
.unwrap()
.to_string()
.contains("HTTPS"));
}
}