use std::sync::Arc;
use std::time::Duration;
use axum::body::Body;
use axum::http::{header, HeaderMap, Method, Response, StatusCode};
use futures_util::stream;
use super::worker::{Worker, WorkerRegistry};
use super::BrokerState;
pub const MAX_RELAY_BODY_BYTES: usize = 64 * 1024 * 1024;
const PREFIX: &str = "/atelier/workers/";
#[derive(Clone, Default)]
pub struct RelayConfig {
relay_token: Option<String>,
runner_token: Option<String>,
}
fn env_or_file(name: &str) -> Option<String> {
let inline = std::env::var(name).ok();
let from_file = std::env::var(format!("{name}_FILE"))
.ok()
.and_then(|p| std::fs::read_to_string(p).ok());
inline
.or(from_file)
.map(|v| v.trim().to_string())
.filter(|v| !v.is_empty())
}
impl RelayConfig {
pub fn from_env() -> Self {
let relay_token = env_or_file("ZAKURO_ATELIER_RELAY_TOKEN");
let runner_token = env_or_file("ZAKURO_ATELIER_RUNNER_TOKEN").or(relay_token.clone());
Self {
relay_token,
runner_token,
}
}
#[cfg(test)]
pub fn with_tokens(relay: &str, runner: &str) -> Self {
Self {
relay_token: Some(relay.to_string()),
runner_token: Some(runner.to_string()),
}
}
pub fn enabled(&self) -> bool {
self.relay_token.is_some()
}
}
fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
if a.len() != b.len() {
return false;
}
a.iter().zip(b).fold(0u8, |acc, (x, y)| acc | (x ^ y)) == 0
}
pub fn allowed(method: &Method, rest: &str) -> bool {
let seg: Vec<&str> = rest.split('/').collect();
let plain = |s: &str| {
!s.is_empty()
&& s.chars().any(|c| c != '.')
&& s.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '_' | '.' | '-'))
};
if !seg.iter().all(|s| plain(s)) {
return false;
}
let get = method == Method::GET;
let post = method == Method::POST;
match seg.as_slice() {
["run"] => post,
["health"] | ["benchmark"] | ["status"] => get,
["jobs", _] => get,
["jobs", _, "logs" | "metrics" | "spec"] => get,
["jobs", _, "cancel" | "wrap-up" | "budget"] => post,
["artifacts", _] => get,
["infer", _] => post,
["supervisor", "jobs"] => post,
["supervisor", "jobs", _] => get,
["supervisor", "jobs", _, "logs"] => get,
["supervisor", "jobs", _, "cancel"] => post,
["harness", _, "evaluate" | "compare" | "score-test"] => post,
_ => false,
}
}
pub fn split_path(path: &str) -> Option<(&str, &str)> {
let tail = path.strip_prefix(PREFIX)?;
let (worker, rest) = tail.split_once('/')?;
if worker.is_empty() || rest.is_empty() {
return None;
}
Some((worker, rest))
}
#[derive(Debug, PartialEq, Eq)]
pub enum ResolveError {
Unknown,
Ambiguous,
NotAtelier,
}
pub fn runner_base(worker: &Worker) -> Option<String> {
if !worker.tags.iter().any(|t| t == "atelier") {
return None;
}
let base = worker
.tags
.iter()
.find_map(|t| t.strip_prefix("atelier-runner="))
.unwrap_or(&worker.uri);
let base = base.trim_end_matches('/');
(base.starts_with("http://") || base.starts_with("https://")).then(|| base.to_string())
}
pub fn resolve_worker(workers: &WorkerRegistry, key: &str) -> Result<Worker, ResolveError> {
if let Some(w) = workers.get(key) {
return if runner_base(&w).is_some() {
Ok(w)
} else {
Err(ResolveError::NotAtelier)
};
}
let mut named: Vec<Worker> = workers
.list()
.into_iter()
.filter(|w| w.name == key && runner_base(w).is_some())
.collect();
match named.len() {
0 => Err(ResolveError::Unknown),
1 => Ok(named.remove(0)),
_ => Err(ResolveError::Ambiguous),
}
}
fn json_error(status: StatusCode, error: &str, code: &str) -> Response<Body> {
let body = serde_json::json!({"error": error, "code": code}).to_string();
Response::builder()
.status(status)
.header(header::CONTENT_TYPE, "application/json")
.body(Body::from(body))
.expect("static response")
}
fn bearer(headers: &HeaderMap) -> Option<&str> {
headers
.get(header::AUTHORIZATION)?
.to_str()
.ok()?
.strip_prefix("Bearer ")
}
pub const READ_BOUND: Duration = Duration::from_secs(120);
pub const HARNESS_READ_BOUND: Duration = Duration::from_secs(300);
pub const SCORE_TEST_READ_BOUND: Duration = Duration::from_secs(3900);
pub fn read_bound(rest: &str) -> Duration {
match rest.split('/').collect::<Vec<_>>().as_slice() {
["harness", _, "score-test"] => SCORE_TEST_READ_BOUND,
["harness", _, _] => HARNESS_READ_BOUND,
_ => READ_BOUND,
}
}
#[derive(Clone)]
pub struct RelayClients {
default: reqwest::Client,
harness: reqwest::Client,
score_test: reqwest::Client,
}
impl Default for RelayClients {
fn default() -> Self {
Self::new()
}
}
impl RelayClients {
pub fn new() -> Self {
Self {
default: http_client(READ_BOUND),
harness: http_client(HARNESS_READ_BOUND),
score_test: http_client(SCORE_TEST_READ_BOUND),
}
}
#[cfg(test)]
fn with_bounds(default: Duration, harness: Duration, score_test: Duration) -> Self {
Self {
default: http_client(default),
harness: http_client(harness),
score_test: http_client(score_test),
}
}
fn for_route(&self, rest: &str) -> &reqwest::Client {
match read_bound(rest) {
SCORE_TEST_READ_BOUND => &self.score_test,
HARNESS_READ_BOUND => &self.harness,
_ => &self.default,
}
}
}
pub fn http_client(read_bound: Duration) -> reqwest::Client {
reqwest::Client::builder()
.connect_timeout(Duration::from_secs(10))
.read_timeout(read_bound)
.redirect(reqwest::redirect::Policy::none())
.build()
.expect("reqwest client")
}
const FORWARDED_REQUEST_HEADERS: [&str; 4] =
["content-type", "accept", "x-forge-async", "x-forge-grant"];
const FORWARDED_RESPONSE_HEADERS: [&str; 4] = [
"content-type",
"content-length",
"content-disposition",
"x-forge-sha256",
];
pub async fn relay(
state: Arc<BrokerState>,
config: RelayConfig,
clients: RelayClients,
req: axum::extract::Request,
) -> Response<Body> {
let Some(expected) = config.relay_token.as_deref() else {
return json_error(
StatusCode::NOT_FOUND,
"the Atelier relay is not enabled on this broker",
"RELAY_DISABLED",
);
};
let presented = bearer(req.headers()).unwrap_or("");
if !constant_time_eq(presented.as_bytes(), expected.as_bytes()) {
return json_error(
StatusCode::UNAUTHORIZED,
"relay token required",
"UNAUTHORIZED",
);
}
let method = req.method().clone();
let path = req.uri().path().to_string();
let query = req.uri().query().map(str::to_string);
let Some((key, rest)) = split_path(&path) else {
return json_error(StatusCode::NOT_FOUND, "no such relay path", "NOT_FOUND");
};
if !allowed(&method, rest) {
return json_error(
StatusCode::FORBIDDEN,
"this runner route is not relayed",
"FORBIDDEN",
);
}
let worker = match resolve_worker(&state.workers, key) {
Ok(w) => w,
Err(ResolveError::Ambiguous) => {
return json_error(
StatusCode::CONFLICT,
"several Atelier workers carry this name; use the worker id",
"AMBIGUOUS_WORKER",
)
}
Err(_) => {
return json_error(
StatusCode::NOT_FOUND,
"no Atelier worker registered under this id or name",
"UNKNOWN_WORKER",
)
}
};
let base = runner_base(&worker).expect("resolve_worker returns Atelier workers only");
let mut url = format!("{base}/{rest}");
if let Some(q) = query {
url.push('?');
url.push_str(&q);
}
let mut out = clients.for_route(rest).request(method.clone(), &url);
for name in FORWARDED_REQUEST_HEADERS {
if let Some(v) = req.headers().get(name) {
out = out.header(name, v);
}
}
if let Some(token) = config.runner_token.as_deref() {
out = out.bearer_auth(token);
}
let body = match axum::body::to_bytes(req.into_body(), MAX_RELAY_BODY_BYTES).await {
Ok(b) => b,
Err(_) => {
return json_error(
StatusCode::PAYLOAD_TOO_LARGE,
"request body too large for the relay",
"PAYLOAD_TOO_LARGE",
)
}
};
if !body.is_empty() {
out = out.body(body);
}
let upstream = match out.send().await {
Ok(r) => r,
Err(e) => {
let (reason, code) = if e.is_connect() {
("could not be reached", "RUNNER_UNREACHABLE")
} else if e.is_timeout() {
("did not answer in time", "RUNNER_NO_ANSWER")
} else {
("did not answer", "RUNNER_NO_ANSWER")
};
return json_error(
StatusCode::BAD_GATEWAY,
&format!("the runner {reason}"),
code,
);
}
};
let status = upstream.status();
if method == Method::POST && rest == "run" && status.is_success() {
state.workers.mark_busy(&worker.id);
}
let mut builder = Response::builder().status(status.as_u16());
for name in FORWARDED_RESPONSE_HEADERS {
if let Some(v) = upstream.headers().get(name) {
builder = builder.header(name, v.as_bytes());
}
}
builder = builder.header("x-zakuro-worker-id", worker.id.as_str());
let chunks = stream::unfold(upstream, |mut r| async move {
match r.chunk().await {
Ok(Some(c)) => Some((Ok::<_, std::io::Error>(c), r)),
Ok(None) => None,
Err(e) => Some((Err(std::io::Error::other(e.to_string())), r)),
}
});
builder.body(Body::from_stream(chunks)).unwrap_or_else(|_| {
json_error(
StatusCode::BAD_GATEWAY,
"bad runner response",
"BAD_GATEWAY",
)
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::broker::worker::WorkerRegistration;
fn register(reg: &WorkerRegistry, name: &str, uri: &str, tags: &[&str]) -> Worker {
let body = serde_json::json!({
"name": name,
"uri": uri,
"worker_type": "atelier",
"tags": tags,
});
let registration: WorkerRegistration = serde_json::from_value(body).unwrap();
reg.register(registration)
}
#[test]
fn only_runner_contract_routes_are_relayed() {
for (m, p) in [
(Method::POST, "run"),
(Method::GET, "health"),
(Method::GET, "benchmark"),
(Method::GET, "jobs/j1"),
(Method::GET, "jobs/j1/logs"),
(Method::GET, "jobs/j1/metrics"),
(Method::GET, "jobs/j1/spec"),
(Method::POST, "jobs/j1/cancel"),
(Method::POST, "jobs/j1/wrap-up"),
(Method::POST, "jobs/j1/budget"),
(Method::GET, "artifacts/j1"),
(Method::POST, "infer/j1"),
] {
assert!(allowed(&m, p), "{m} {p}");
}
for (m, p) in [
(Method::GET, "run"),
(Method::POST, "drain"),
(Method::DELETE, "jobs/j1"),
(Method::GET, "jobs/../../etc/passwd"),
(Method::GET, "jobs//logs"),
(Method::GET, "jobs/%2e%2e/logs"),
(Method::GET, "jobs/a%2Fb"),
(Method::GET, "jobs/..."),
(Method::GET, "artifacts/j 1"),
(Method::GET, "jobs/j1/logs/extra"),
(Method::GET, ""),
(Method::POST, "artifacts/j1"),
] {
assert!(!allowed(&m, p), "{m} {p}");
}
}
#[test]
fn the_supervisor_and_harness_routes_are_the_seven_the_hub_calls() {
for (m, p) in [
(Method::POST, "supervisor/jobs"),
(Method::GET, "supervisor/jobs/20261116T101500-train-ab12"),
(Method::GET, "supervisor/jobs/j1/logs"),
(Method::POST, "supervisor/jobs/j1/cancel"),
(Method::POST, "harness/avm-2026/evaluate"),
(Method::POST, "harness/avm-2026/compare"),
(Method::POST, "harness/avm-2026/score-test"),
] {
assert!(allowed(&m, p), "{m} {p}");
}
for (m, p) in [
(Method::GET, "supervisor/jobs"),
(Method::POST, "supervisor/jobs/j1"),
(Method::DELETE, "supervisor/jobs/j1"),
(Method::POST, "supervisor/jobs/j1/logs"),
(Method::GET, "supervisor/jobs/j1/cancel"),
(Method::GET, "harness/p/evaluate"),
(Method::GET, "harness/p/compare"),
(Method::GET, "harness/p/score-test"),
(Method::PUT, "harness/p/evaluate"),
(Method::GET, "supervisor"),
(Method::POST, "supervisor"),
(Method::GET, "supervisor/volumes"),
(Method::POST, "supervisor/jobs/j1/retry"),
(Method::GET, "supervisor/jobs/j1/logs/extra"),
(Method::POST, "supervisor/jobs/j1/cancel/now"),
(Method::GET, "harness"),
(Method::POST, "harness/p"),
(Method::POST, "harness/p/run"),
(Method::POST, "harness/p/score_test"),
(Method::POST, "harness/p/evaluate/extra"),
(Method::POST, "harness/evaluate"),
(Method::GET, "supervisor/jobs/.."),
(Method::GET, "supervisor/jobs//logs"),
(Method::GET, "supervisor/jobs/%2e%2e/logs"),
(Method::GET, "supervisor/jobs/a%2Fb"),
(Method::POST, "harness/../evaluate"),
(Method::POST, "harness//evaluate"),
(Method::POST, "harness/a%2Fb/evaluate"),
(Method::POST, "harness/my project/evaluate"),
] {
assert!(!allowed(&m, p), "{m} {p}");
}
}
#[test]
fn path_splits_into_worker_and_runner_route() {
assert_eq!(
split_path("/atelier/workers/w1/jobs/j1/logs"),
Some(("w1", "jobs/j1/logs"))
);
assert_eq!(split_path("/atelier/workers/w1"), None);
assert_eq!(split_path("/atelier/workers//run"), None);
assert_eq!(split_path("/workers/w1/run"), None);
}
#[test]
fn runner_url_comes_from_the_tag_then_the_uri_and_only_for_atelier_workers() {
let reg = WorkerRegistry::new();
let tagged = register(
®,
"a",
"http://10.0.0.1:1",
&["atelier", "atelier-runner=http://10.0.0.2:8102/"],
);
assert_eq!(
runner_base(&tagged).as_deref(),
Some("http://10.0.0.2:8102")
);
let plain = register(®, "b", "http://10.0.0.3:8102", &["atelier"]);
assert_eq!(runner_base(&plain).as_deref(), Some("http://10.0.0.3:8102"));
let other = register(®, "c", "http://10.0.0.4:3960", &[]);
assert_eq!(runner_base(&other), None);
}
#[test]
fn a_worker_resolves_by_id_then_by_unique_name() {
let reg = WorkerRegistry::new();
let a = register(®, "x399", "http://10.0.0.1:8102", &["atelier"]);
let id = |key: &str| resolve_worker(®, key).map(|w| w.id);
assert_eq!(id(&a.id), Ok(a.id.clone()));
assert_eq!(id("x399"), Ok(a.id.clone()));
assert_eq!(id("nope"), Err(ResolveError::Unknown));
let plain = register(®, "cpu", "http://10.0.0.9:3960", &[]);
assert_eq!(id(&plain.id), Err(ResolveError::NotAtelier));
assert_eq!(id("cpu"), Err(ResolveError::Unknown));
register(®, "x399", "http://10.0.0.5:8102", &["atelier"]);
assert_eq!(id("x399"), Err(ResolveError::Ambiguous));
}
#[test]
fn token_comparison_is_exact() {
assert!(constant_time_eq(b"abc", b"abc"));
assert!(!constant_time_eq(b"abc", b"abd"));
assert!(!constant_time_eq(b"abc", b"ab"));
assert!(!constant_time_eq(b"", b"a"));
}
async fn fake_runner() -> std::net::SocketAddr {
use axum::routing::{get, post};
let authed = |h: &HeaderMap| bearer(h) == Some("runner-secret");
let app = axum::Router::new()
.route(
"/run",
post(move |h: HeaderMap, body: String| async move {
if !authed(&h) {
return (StatusCode::UNAUTHORIZED, String::new());
}
let is_async = h.get("x-forge-async").is_some();
(
StatusCode::ACCEPTED,
format!("async={is_async} body={body}"),
)
}),
)
.route(
"/jobs/j1/logs",
get(move |h: HeaderMap, uri: axum::http::Uri| async move {
if !authed(&h) {
return (StatusCode::UNAUTHORIZED, String::new());
}
(StatusCode::OK, uri.query().unwrap_or("").to_string())
}),
)
.route(
"/supervisor/jobs/s1/logs",
get(move |h: HeaderMap, uri: axum::http::Uri| async move {
if !authed(&h) {
return (StatusCode::UNAUTHORIZED, String::new());
}
(StatusCode::OK, uri.query().unwrap_or("").to_string())
}),
)
.route(
"/harness/p1/score-test",
post(move |h: HeaderMap, body: String| async move {
if !authed(&h) {
return (StatusCode::UNAUTHORIZED, String::new());
}
(StatusCode::OK, format!("scored {body}"))
}),
)
.route(
"/harness/p1/elsewhere",
post(|| async {
(
StatusCode::TEMPORARY_REDIRECT,
[(header::LOCATION, "http://127.0.0.1:1/away")],
)
}),
)
.route(
"/harness/p1/compare",
post(|| async {
(
StatusCode::TEMPORARY_REDIRECT,
[(header::LOCATION, "/harness/p1/score-test")],
)
}),
)
.route(
"/artifacts/j1",
get(|| async { vec![7u8; 6 * 1024 * 1024] }),
);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
addr
}
fn request(
method: Method,
path: &str,
token: Option<&str>,
body: &str,
) -> axum::extract::Request {
let mut b = axum::http::Request::builder().method(method).uri(path);
if let Some(t) = token {
b = b.header(header::AUTHORIZATION, format!("Bearer {t}"));
}
b.header("x-forge-async", "1")
.body(Body::from(body.to_string()))
.unwrap()
}
async fn text(resp: Response<Body>) -> (u16, Vec<u8>) {
let status = resp.status().as_u16();
let bytes = axum::body::to_bytes(resp.into_body(), usize::MAX)
.await
.unwrap();
(status, bytes.to_vec())
}
#[tokio::test]
async fn a_call_reaches_the_runner_with_the_brokers_token_and_marks_it_busy() {
let addr = fake_runner().await;
let state = Arc::new(BrokerState::new());
let w = register(
&state.workers,
"x399",
&format!("http://{addr}"),
&["atelier"],
);
let cfg = RelayConfig::with_tokens("hub-secret", "runner-secret");
let go = |req| relay(state.clone(), cfg.clone(), RelayClients::new(), req);
let (status, _) = text(
go(request(
Method::GET,
"/atelier/workers/x399/jobs/j1/logs",
None,
"",
))
.await,
)
.await;
assert_eq!(status, 401);
let (status, _) = text(
go(request(
Method::GET,
"/atelier/workers/x399/jobs/j1/logs",
Some("runner-secret"),
"",
))
.await,
)
.await;
assert_eq!(status, 401);
let (status, body) = text(
go(request(
Method::GET,
"/atelier/workers/x399/jobs/j1/logs?tail_bytes=9",
Some("hub-secret"),
"",
))
.await,
)
.await;
assert_eq!((status, body.as_slice()), (200, b"tail_bytes=9".as_slice()));
assert_eq!(state.workers.get(&w.id).unwrap().active_requests, 0);
let (status, body) = text(
go(request(
Method::POST,
&format!("/atelier/workers/{}/run", w.id),
Some("hub-secret"),
"{\"job_id\":\"j1\"}",
))
.await,
)
.await;
assert_eq!(status, 202);
assert_eq!(body, b"async=true body={\"job_id\":\"j1\"}");
let busy = state.workers.get(&w.id).unwrap();
assert_eq!(busy.active_requests, 1);
assert_eq!(busy.resources.gpus_available, 0);
let (status, body) = text(
go(request(
Method::GET,
"/atelier/workers/x399/artifacts/j1",
Some("hub-secret"),
"",
))
.await,
)
.await;
assert_eq!((status, body.len()), (200, 6 * 1024 * 1024));
let before = state.workers.get(&w.id).unwrap().active_requests;
let (status, body) = text(
go(request(
Method::GET,
"/atelier/workers/x399/supervisor/jobs/s1/logs?tail=200",
Some("hub-secret"),
"",
))
.await,
)
.await;
assert_eq!((status, body.as_slice()), (200, b"tail=200".as_slice()));
let (status, body) = text(
go(request(
Method::POST,
"/atelier/workers/x399/harness/p1/score-test",
Some("hub-secret"),
"{\"system\":\"s\"}",
))
.await,
)
.await;
assert_eq!(
(status, body.as_slice()),
(200, b"scored {\"system\":\"s\"}".as_slice())
);
let (status, _) = text(
go(request(
Method::POST,
"/atelier/workers/x399/harness/p1/score-test",
Some("runner-secret"),
"",
))
.await,
)
.await;
assert_eq!(status, 401);
let (status, body) = text(
go(request(
Method::POST,
"/atelier/workers/x399/harness/p1/compare",
Some("hub-secret"),
"{}",
))
.await,
)
.await;
assert_eq!(status, 307);
assert!(!body.starts_with(b"scored"));
for (m, p) in [
(Method::GET, "/atelier/workers/x399/harness/p1/score-test"),
(Method::POST, "/atelier/workers/x399/harness/p1/elsewhere"),
(
Method::POST,
"/atelier/workers/x399/supervisor/jobs/s1/logs",
),
] {
let (status, _) = text(go(request(m, p, Some("hub-secret"), "")).await).await;
assert_eq!(status, 403, "{p}");
}
assert_eq!(state.workers.get(&w.id).unwrap().active_requests, before);
let (status, _) = text(
go(request(
Method::POST,
"/atelier/workers/x399/drain",
Some("hub-secret"),
"",
))
.await,
)
.await;
assert_eq!(status, 403);
let (status, _) = text(
go(request(
Method::GET,
"/atelier/workers/nobody/health",
Some("hub-secret"),
"",
))
.await,
)
.await;
assert_eq!(status, 404);
}
#[test]
fn a_harness_call_may_be_silent_for_longer_than_any_other() {
for p in [
"run",
"health",
"jobs/j1/logs",
"artifacts/j1",
"infer/j1",
"supervisor/jobs",
"supervisor/jobs/j1",
"supervisor/jobs/j1/logs",
"supervisor/jobs/j1/cancel",
] {
assert_eq!(read_bound(p), Duration::from_secs(120), "{p}");
}
assert_eq!(read_bound("harness/p/evaluate"), HARNESS_READ_BOUND);
assert_eq!(read_bound("harness/p/compare"), HARNESS_READ_BOUND);
assert_eq!(read_bound("harness/p/score-test"), SCORE_TEST_READ_BOUND);
assert!(HARNESS_READ_BOUND > Duration::from_secs(120));
assert!(SCORE_TEST_READ_BOUND > Duration::from_secs(3600));
}
#[tokio::test]
async fn each_route_is_cut_at_its_own_read_bound() {
use axum::routing::{get, post};
let slow = || async {
tokio::time::sleep(Duration::from_millis(600)).await;
"done"
};
let app = axum::Router::new()
.route("/jobs/j1", get(slow))
.route("/supervisor/jobs/s1", get(slow))
.route("/harness/p1/evaluate", post(slow))
.route("/harness/p1/score-test", post(slow));
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
let state = Arc::new(BrokerState::new());
register(
&state.workers,
"x399",
&format!("http://{addr}"),
&["atelier"],
);
let cfg = RelayConfig::with_tokens("hub-secret", "runner-secret");
let ms = Duration::from_millis;
let call = |clients: RelayClients, method: Method, route: &str| {
let path = format!("/atelier/workers/x399/{route}");
let (state, cfg) = (state.clone(), cfg.clone());
async move {
let resp = relay(
state,
cfg,
clients,
request(method, &path, Some("hub-secret"), ""),
);
let (status, body) = text(resp.await).await;
(status, String::from_utf8(body).unwrap())
}
};
let clients = RelayClients::with_bounds(ms(150), ms(150), ms(5000));
let (status, body) = call(clients.clone(), Method::POST, "harness/p1/score-test").await;
assert_eq!((status, body.as_str()), (200, "done"));
for (m, route) in [
(Method::GET, "jobs/j1"),
(Method::GET, "supervisor/jobs/s1"),
(Method::POST, "harness/p1/evaluate"),
] {
let (status, body) = call(clients.clone(), m, route).await;
assert_eq!(status, 502, "{route}");
assert!(body.contains("RUNNER_NO_ANSWER"), "{route}: {body}");
}
let clients = RelayClients::with_bounds(ms(150), ms(5000), ms(150));
let (status, _) = call(clients.clone(), Method::POST, "harness/p1/evaluate").await;
assert_eq!(status, 200);
let (status, _) = call(clients.clone(), Method::GET, "supervisor/jobs/s1").await;
assert_eq!(status, 502);
let (status, _) = call(clients, Method::POST, "harness/p1/score-test").await;
assert_eq!(status, 502);
}
#[tokio::test]
async fn the_relay_is_off_without_a_token_and_hides_a_dead_runners_address() {
let state = Arc::new(BrokerState::new());
register(&state.workers, "gone", "http://127.0.0.1:1", &["atelier"]);
let off = relay(
state.clone(),
RelayConfig::default(),
RelayClients::new(),
request(Method::GET, "/atelier/workers/gone/health", Some("x"), ""),
)
.await;
assert_eq!(off.status(), 404);
let cfg = RelayConfig::with_tokens("hub-secret", "runner-secret");
let (status, body) = text(
relay(
state,
cfg,
RelayClients::new(),
request(
Method::GET,
"/atelier/workers/gone/health",
Some("hub-secret"),
"",
),
)
.await,
)
.await;
assert_eq!(status, 502);
let body = String::from_utf8(body).unwrap();
assert!(body.contains("RUNNER_UNREACHABLE"), "{body}");
assert!(!body.contains("127.0.0.1"), "{body}");
}
}