use super::coral_compiler::DEFAULT_ECOPRIMALS_DISCOVERY_DIR;
use crate::env_keys;
pub(super) const DISPATCH_CAPABILITY: &str = "compute.dispatch";
pub(super) const DISPATCH_ADDR_ENV: &str = "BARRACUDA_DISPATCH_ADDR";
const DISCOVERY_SUBDIR: &str = "discovery";
#[cfg(feature = "sovereign-dispatch")]
pub(super) fn detect_dispatch_addr() -> Option<String> {
if let Ok(addr) = std::env::var(DISPATCH_ADDR_ENV) {
let addr = addr.trim().to_owned();
if !addr.is_empty() {
return Some(addr);
}
}
let runtime_dir = std::env::var(env_keys::XDG_RUNTIME_DIR).ok()?;
let eco_dir = std::env::var(env_keys::ECOPRIMALS_DISCOVERY_DIR)
.unwrap_or_else(|_| DEFAULT_ECOPRIMALS_DISCOVERY_DIR.to_owned());
let base_dir = std::path::PathBuf::from(runtime_dir).join(eco_dir);
for dir in [&base_dir, &base_dir.join(DISCOVERY_SUBDIR)] {
if let Some(addr) = scan_dispatch_capability(dir) {
return Some(addr);
}
}
None
}
#[cfg(feature = "sovereign-dispatch")]
fn scan_dispatch_capability(dir: &std::path::Path) -> Option<String> {
let entries = std::fs::read_dir(dir).ok()?;
for entry in entries.flatten() {
let path = entry.path();
if path.extension().is_some_and(|e| e == "json") {
if let Some(addr) = read_dispatch_transport(&path) {
return Some(addr);
}
}
}
None
}
#[cfg(feature = "sovereign-dispatch")]
pub(super) fn query_dispatch_arch(addr: &str) -> Option<String> {
let handle = tokio::runtime::Handle::try_current().ok()?;
let addr = addr.to_owned();
tokio::task::block_in_place(|| {
handle.block_on(async {
let host_port = addr.trim_start_matches("http://");
let body = serde_json::json!({
"jsonrpc": "2.0",
"method": "compute.dispatch.capabilities",
"params": [],
"id": 1,
});
let body_str = serde_json::to_string(&body).ok()?;
let http_request = format!(
"POST / HTTP/1.1\r\nHost: {host_port}\r\n\
Content-Type: application/json\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{body_str}",
body_str.len()
);
let timeout = tokio::time::Duration::from_secs(5);
let mut stream =
tokio::time::timeout(timeout, tokio::net::TcpStream::connect(host_port))
.await
.ok()?
.ok()?;
tokio::io::AsyncWriteExt::write_all(&mut stream, http_request.as_bytes())
.await
.ok()?;
let mut buf = Vec::new();
tokio::io::AsyncReadExt::read_to_end(&mut stream, &mut buf)
.await
.ok()?;
let response_str = String::from_utf8_lossy(&buf);
let json_start = response_str.find('{')?;
let rpc: serde_json::Value = serde_json::from_str(&response_str[json_start..]).ok()?;
let result = rpc.get("result")?;
let arch = result.get("arch").and_then(serde_json::Value::as_str);
arch.map(str::to_owned)
})
})
}
#[cfg(feature = "sovereign-dispatch")]
fn read_dispatch_transport(path: &std::path::Path) -> Option<String> {
let content = std::fs::read_to_string(path).ok()?;
let info: serde_json::Value = serde_json::from_str(&content).ok()?;
let has_dispatch = info
.get("provides")
.or_else(|| info.get("capabilities"))
.and_then(|v| v.as_array())
.is_some_and(|caps| {
caps.iter().any(|c| {
c.as_str()
.is_some_and(|s| s.starts_with(DISPATCH_CAPABILITY))
})
});
if !has_dispatch {
return None;
}
let jsonrpc = info.get("transports")?.get("jsonrpc")?;
if let Some(s) = jsonrpc.as_str() {
return Some(s.to_owned());
}
jsonrpc
.get("tcp")
.and_then(|v| v.as_str())
.map(str::to_owned)
}