use std::convert::Infallible;
use std::io;
use std::path::PathBuf;
use std::sync::Arc;
use http_body_util::combinators::UnsyncBoxBody;
use http_body_util::{BodyExt, Empty, StreamBody};
use hyper::body::{Bytes, Frame, Incoming};
use hyper::header::CONTENT_LENGTH;
use hyper::server::conn::http1;
use hyper::service::service_fn;
use hyper::{Method, Request, Response, StatusCode};
use hyper_util::rt::TokioIo;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::UnixStream;
use tokio::sync::watch;
use tracing::debug;
use super::{Inner, Upload, Writes, charge, valid_segment};
use crate::sync::lock;
pub(super) type Body = UnsyncBoxBody<Bytes, io::Error>;
const TOOLS: [(&str, &str); 5] = [
("gradle", ""),
("sccache", ""),
("bazel", ""),
(super::turbo::TOOL, "v8/artifacts/"),
("nx", "v1/cache/"),
];
const MAX_SEGMENTS: usize = 8;
const CHUNK: usize = 64 << 10;
pub(super) async fn connection(inner: Arc<Inner>, runner: String, stream: UnixStream) {
let service = service_fn(move |request| {
let inner = inner.clone();
let runner = runner.clone();
async move { Ok::<_, Infallible>(handle(&inner, &runner, request).await) }
});
if let Err(error) = http1::Builder::new()
.serve_connection(TokioIo::new(stream), service)
.await
{
debug!("a build cache connection ended: {error}");
}
}
async fn handle(inner: &Arc<Inner>, runner: &str, request: Request<Incoming>) -> Response<Body> {
let Some(repository) = lock(&inner.state)
.runners
.get(runner)
.map(|open| open.repository.clone())
else {
return status(StatusCode::SERVICE_UNAVAILABLE);
};
let path = request.uri().path().trim_start_matches('/').to_owned();
if path.starts_with(super::actions::TWIRP) || path.starts_with(super::actions::BLOBS) {
return super::actions::handle(inner, runner, request).await;
}
if (path == super::turbo::TOOL || path.starts_with("turbo/")) && super::turbo::foreign(&request)
{
return super::turbo::pass(inner, request).await;
}
if let Some(endpoint) = path.strip_prefix(super::turbo::API)
&& super::turbo::ENDPOINTS.contains(&endpoint)
{
return super::turbo::handle(inner, &repository, endpoint, request).await;
}
let Some((tool, rest)) = path.split_once('/').and_then(|(name, rest)| {
let (tool, api) = TOOLS.iter().find(|(tool, _)| *tool == name)?;
Some((*tool, rest.strip_prefix(api)?))
}) else {
return status(StatusCode::NOT_FOUND);
};
let segments: Vec<&str> = rest.split('/').collect();
if segments.len() > MAX_SEGMENTS || !segments.iter().all(|segment| valid_segment(segment)) {
return status(StatusCode::NOT_FOUND);
}
let mut entry = PathBuf::from(&repository);
entry.push(tool);
entry.extend(&segments);
let counted = !segments.last().is_some_and(|last| last.starts_with('.'));
match *request.method() {
Method::GET => read(inner, runner, entry, counted, ReadKind::Body).await,
Method::HEAD => read(inner, runner, entry, false, ReadKind::Head).await,
Method::PUT => write(inner, runner, entry, request.into_body()).await,
_ => status(StatusCode::METHOD_NOT_ALLOWED),
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ReadKind {
Body,
Head,
}
async fn read(
inner: &Inner,
runner: &str,
entry: PathBuf,
counted: bool,
kind: ReadKind,
) -> Response<Body> {
let known = lock(&inner.state).entries.contains_key(&entry);
let file = if known {
tokio::fs::File::open(inner.root.join(&entry)).await.ok()
} else {
None
};
let opened = match file {
Some(file) => file
.metadata()
.await
.ok()
.map(|metadata| (file, metadata.len())),
None => None,
};
let Some((file, bytes)) = opened else {
if counted && let Some(open) = lock(&inner.state).runners.get_mut(runner) {
open.counts.misses += 1;
}
return status(StatusCode::NOT_FOUND);
};
if counted {
if let Some(open) = lock(&inner.state).runners.get_mut(runner) {
open.counts.hits += 1;
open.counts.read_bytes += bytes;
}
inner.touch(&entry);
}
let body = match kind {
ReadKind::Head => Empty::new().map_err(|never| match never {}).boxed_unsync(),
ReadKind::Body => {
let chunks = futures_util::stream::unfold(file, |mut file| async move {
let mut chunk = vec![0; CHUNK];
match file.read(&mut chunk).await {
Ok(0) => None,
Ok(read) => {
chunk.truncate(read);
Some((Ok(Frame::data(Bytes::from(chunk))), file))
}
Err(error) => Some((Err(error), file)),
}
});
BodyExt::boxed_unsync(StreamBody::new(chunks))
}
};
let mut response = Response::new(body);
response.headers_mut().insert(CONTENT_LENGTH, bytes.into());
response
}
async fn write(inner: &Inner, runner: &str, entry: PathBuf, body: Incoming) -> Response<Body> {
use hyper::body::Body as _;
let (writes, max_size) = {
let state = lock(&inner.state);
let writes = state.runners.get(runner).map(|open| open.writes.current());
(writes, state.max_size)
};
let refused = || {
if let Some(open) = lock(&inner.state).runners.get_mut(runner) {
open.counts.refused += 1;
}
accepted()
};
let length = body.size_hint().exact();
let same = length.is_some_and(|length| {
lock(&inner.state)
.entries
.get(&entry)
.is_some_and(|known| known.bytes == length)
});
if same && writes == Some(Writes::Allowed) {
drain(body).await;
inner.touch(&entry);
return accepted();
}
match writes {
None => return status(StatusCode::SERVICE_UNAVAILABLE),
Some(Writes::Refused) => {
drain(body).await;
return refused();
}
Some(Writes::Allowed | Writes::Undecided) => {}
}
let mut receiving = Receiving::new(inner, runner, max_size, Purpose::Build);
match receive(&mut receiving, body).await {
Ok(true) => {}
Ok(false) => return refused(),
Err(error) => {
debug!("{runner}: a build cache upload failed: {error}");
return status(StatusCode::INTERNAL_SERVER_ERROR);
}
}
let upload = receiving.into_upload(entry);
let (writes, upload) = {
let mut state = lock(&inner.state);
match state.runners.get_mut(runner) {
Some(open) => match open.writes.hold(upload) {
Ok(()) => return accepted(),
Err(upload) => (Some(open.writes.current()), upload),
},
None => (None, upload),
}
};
if writes == Some(Writes::Allowed) {
inner.store(runner, upload);
accepted()
} else {
inner.remove_uploads(Some(runner), &[upload]);
refused()
}
}
#[derive(Debug, Clone, Copy)]
pub(super) enum Purpose {
Build,
Save(u64),
}
pub(super) struct Receiving<'inner> {
inner: &'inner Inner,
runner: &'inner str,
file: PathBuf,
bytes: u64,
room: u64,
max_size: u64,
purpose: Purpose,
decided: Option<watch::Receiver<()>>,
}
impl<'inner> Receiving<'inner> {
pub(super) fn new(
inner: &'inner Inner,
runner: &'inner str,
max_size: u64,
purpose: Purpose,
) -> Receiving<'inner> {
let (file, decided) = {
let mut state = lock(&inner.state);
state.next_upload += 1;
let decided = state
.runners
.get(runner)
.map(|open| open.decided.subscribe());
(inner.uploads.join(state.next_upload.to_string()), decided)
};
Receiving {
inner,
runner,
file,
bytes: 0,
room: 0,
max_size,
purpose,
decided,
}
}
fn wanted(&self) -> bool {
lock(&self.inner.state)
.runners
.get(self.runner)
.is_some_and(|open| match self.purpose {
Purpose::Build => open.writes.current() != Writes::Refused,
Purpose::Save(id) => super::actions::takes_uploads(&open.saves, id),
})
}
fn grow(&mut self, length: u64) -> bool {
let bytes = self.bytes + length;
let more = charge(bytes).saturating_sub(self.room);
if bytes > self.max_size / 4
|| more > 0 && !self.inner.reserve(self.runner, more, self.max_size)
{
return false;
}
self.bytes = bytes;
self.room += more;
true
}
fn give_up(&mut self) {
let _ = std::fs::remove_file(&self.file);
self.inner.release(Some(self.runner), self.room);
self.file = PathBuf::new();
self.bytes = 0;
self.room = 0;
}
pub(super) fn into_upload(mut self, entry: PathBuf) -> Upload {
Upload {
file: std::mem::take(&mut self.file),
entry,
bytes: std::mem::take(&mut self.bytes),
room: std::mem::take(&mut self.room),
}
}
}
impl Drop for Receiving<'_> {
fn drop(&mut self) {
if !self.file.as_os_str().is_empty() {
let _ = std::fs::remove_file(&self.file);
self.inner.release(Some(self.runner), self.room);
}
}
}
pub(super) async fn receive(receiving: &mut Receiving<'_>, mut body: Incoming) -> io::Result<bool> {
let mut decided = receiving.decided.take();
if !receiving.wanted() || !receiving.grow(0) {
receiving.give_up();
drain(body).await;
return Ok(false);
}
let mut out = tokio::fs::File::create(&receiving.file).await?;
loop {
tokio::select! {
frame = body.frame() => {
let Some(frame) = frame else {
break;
};
let frame = frame.map_err(io::Error::other)?;
if let Ok(data) = frame.into_data() {
if !receiving.grow(data.len() as u64) {
close(out).await;
receiving.give_up();
drain(body).await;
return Ok(false);
}
out.write_all(&data).await?;
}
}
Some(Ok(())) = changed(&mut decided) => {
if !receiving.wanted() {
close(out).await;
receiving.give_up();
drain(body).await;
return Ok(false);
}
}
}
}
out.flush().await?;
Ok(true)
}
async fn close(out: tokio::fs::File) {
drop(out.into_std().await);
}
async fn changed(
decided: &mut Option<watch::Receiver<()>>,
) -> Option<Result<(), watch::error::RecvError>> {
Some(decided.as_mut()?.changed().await)
}
pub(super) async fn drain(mut body: Incoming) {
while let Some(Ok(_)) = body.frame().await {}
}
fn accepted() -> Response<Body> {
status(StatusCode::OK)
}
pub(super) fn status(code: StatusCode) -> Response<Body> {
let mut response = Response::new(Empty::new().map_err(|never| match never {}).boxed_unsync());
*response.status_mut() = code;
response
}