use std::path::PathBuf;
use super::jsonrpc::jsonrpc_call;
use super::types::HealthResponse;
use crate::env_keys;
const COMPILER_ADDR_ENV: &str = "BARRACUDA_SHADER_COMPILER_ADDR";
const COMPILER_PORT_ENV: &str = "BARRACUDA_SHADER_COMPILER_PORT";
const LOCALHOST: &str = "127.0.0.1";
const LEGACY_DISCOVERY_FILENAME: &str = "shader-compiler.json";
fn resolve_ecosystem_namespace() -> String {
std::env::var(env_keys::BIOMEOS_SOCKET_DIR)
.unwrap_or_else(|_| env_keys::DEFAULT_ECOSYSTEM_SOCKET_NAMESPACE.to_owned())
}
pub const DEFAULT_ECOPRIMALS_DISCOVERY_DIR: &str = "ecoPrimals";
const SHADER_CAPABILITY_SOCKET: &str = "shader.sock";
pub async fn discover_shader_compiler() -> Option<String> {
if let Ok(addr) = std::env::var(COMPILER_ADDR_ENV) {
let addr = addr.trim().to_owned();
if !addr.is_empty() && probe_jsonrpc(&addr).await {
tracing::debug!(addr = %addr, "shader compiler discovered via {COMPILER_ADDR_ENV}");
return Some(addr);
}
}
if let Some(addr) = discover_from_socket().await {
return Some(addr);
}
if let Some(addr) = discover_from_file().await
&& probe_jsonrpc(&addr).await
{
return Some(addr);
}
if let Some(port) = std::env::var(COMPILER_PORT_ENV)
.ok()
.and_then(|s| s.trim().parse::<u16>().ok())
{
let explicit_addr = format!("{LOCALHOST}:{port}");
if probe_jsonrpc(&explicit_addr).await {
return Some(explicit_addr);
}
}
None
}
#[cfg(unix)]
async fn discover_from_socket() -> Option<String> {
let runtime_dir = std::env::var(env_keys::XDG_RUNTIME_DIR).ok()?;
let socket_path = PathBuf::from(&runtime_dir)
.join(resolve_ecosystem_namespace())
.join(SHADER_CAPABILITY_SOCKET);
if !socket_path.exists() {
return None;
}
let addr = format!("unix:{}", socket_path.display());
if probe_jsonrpc(&addr).await {
tracing::debug!(
path = %socket_path.display(),
"shader compiler discovered via capability-domain socket"
);
return Some(addr);
}
None
}
#[cfg(not(unix))]
async fn discover_from_socket() -> Option<String> {
None
}
async fn discover_from_file() -> Option<String> {
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 eco_base = PathBuf::from(&runtime_dir).join(&eco_dir);
let eco_canonical = eco_base.join("discovery");
let biomeos_base = PathBuf::from(&runtime_dir).join(resolve_ecosystem_namespace());
let dirs = [&eco_base, &eco_canonical, &biomeos_base];
for dir in &dirs {
if let Some(addr) = scan_capability(dir, "shader.compile") {
return Some(addr);
}
}
for dir in &dirs {
if let Some(addr) = scan_capability(dir, "shader_compiler") {
return Some(addr);
}
}
let legacy_path = eco_base.join(LEGACY_DISCOVERY_FILENAME);
read_jsonrpc_transport(&legacy_path)
}
fn scan_capability(dir: &std::path::Path, capability: &str) -> 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")
&& let Some(addr) = read_capability_transport(&path, capability)
{
return Some(addr);
}
}
None
}
fn read_capability_transport(path: &std::path::Path, capability: &str) -> Option<String> {
let content = std::fs::read_to_string(path).ok()?;
let info: serde_json::Value = serde_json::from_str(&content).ok()?;
let has_cap = 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() == Some(capability)));
if !has_cap {
return None;
}
read_jsonrpc_from_value(&info)
}
fn read_jsonrpc_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()?;
read_jsonrpc_from_value(&info)
}
fn read_jsonrpc_from_value(info: &serde_json::Value) -> Option<String> {
let jsonrpc = info.get("transports")?.get("jsonrpc")?;
if let Some(s) = jsonrpc.as_str() {
return Some(s.to_owned());
}
if let Some(unix_path) = jsonrpc.get("unix").and_then(|v| v.as_str())
&& std::path::Path::new(unix_path).exists()
{
return Some(format!("unix:{unix_path}"));
}
jsonrpc
.get("tcp")
.and_then(|v| v.as_str())
.map(str::to_owned)
}
pub async fn discover_cpu_shader_compiler() -> Option<String> {
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 eco_base = PathBuf::from(&runtime_dir).join(&eco_dir);
let eco_canonical = eco_base.join("discovery");
let biomeos_base = PathBuf::from(&runtime_dir).join(resolve_ecosystem_namespace());
let dirs = [&eco_base, &eco_canonical, &biomeos_base];
for dir in &dirs {
if let Some(addr) = scan_capability(dir, "shader.compile.cpu")
&& probe_jsonrpc(&addr).await
{
return Some(addr);
}
}
for dir in &dirs {
if let Some(addr) = scan_capability(dir, "shader.execute.cpu")
&& probe_jsonrpc(&addr).await
{
return Some(addr);
}
}
None
}
pub async fn discover_shader_validator() -> Option<String> {
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 eco_base = PathBuf::from(&runtime_dir).join(&eco_dir);
let eco_canonical = eco_base.join("discovery");
let biomeos_base = PathBuf::from(&runtime_dir).join(resolve_ecosystem_namespace());
let dirs = [&eco_base, &eco_canonical, &biomeos_base];
for dir in &dirs {
if let Some(addr) = scan_capability(dir, "shader.validate")
&& probe_jsonrpc(&addr).await
{
return Some(addr);
}
}
None
}
pub async fn probe_jsonrpc(addr: &str) -> bool {
match jsonrpc_call::<(), HealthResponse>(addr, "shader.compile.status", &()).await {
Ok(resp) => {
tracing::debug!(
name = resp.name,
version = resp.version,
"shader compiler health OK"
);
true
}
Err(_) => {
jsonrpc_call::<(), HealthResponse>(addr, "compiler.health", &())
.await
.is_ok()
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn read_jsonrpc_from_value_string_format() {
let info: serde_json::Value = serde_json::json!({
"transports": {
"jsonrpc": "127.0.0.1:5000"
}
});
assert_eq!(
read_jsonrpc_from_value(&info),
Some("127.0.0.1:5000".to_owned())
);
}
#[test]
fn read_jsonrpc_from_value_phase10_object_format() {
let info: serde_json::Value = serde_json::json!({
"transports": {
"jsonrpc": {
"tcp": "127.0.0.1:5000",
"path": "/run/ecoPrimals/shader-compiler.sock"
}
}
});
assert_eq!(
read_jsonrpc_from_value(&info),
Some("127.0.0.1:5000".to_owned())
);
}
#[test]
fn read_jsonrpc_from_value_unix_socket_preferred_when_exists() {
let dir = std::env::temp_dir().join("barracuda_test_unix_pref");
let _ = std::fs::create_dir_all(&dir);
let sock = dir.join("shader.sock");
std::fs::write(&sock, b"").unwrap();
let info: serde_json::Value = serde_json::json!({
"transports": {
"jsonrpc": {
"unix": sock.to_str().unwrap(),
"tcp": "127.0.0.1:5000"
}
}
});
let result = read_jsonrpc_from_value(&info);
assert!(result.is_some());
let addr = result.unwrap();
assert!(
addr.starts_with("unix:"),
"should prefer unix socket: {addr}"
);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn read_jsonrpc_from_value_unix_falls_back_to_tcp_when_missing() {
let info: serde_json::Value = serde_json::json!({
"transports": {
"jsonrpc": {
"unix": "/nonexistent/path/shader.sock",
"tcp": "127.0.0.1:5000"
}
}
});
assert_eq!(
read_jsonrpc_from_value(&info),
Some("127.0.0.1:5000".to_owned()),
);
}
#[test]
fn read_jsonrpc_from_value_no_transport() {
let info: serde_json::Value = serde_json::json!({
"name": "some-primal"
});
assert_eq!(read_jsonrpc_from_value(&info), None);
}
#[test]
fn read_capability_transport_provides_array() {
let dir = std::env::temp_dir().join("barracuda_test_discovery");
let _ = std::fs::create_dir_all(&dir);
let manifest = dir.join("test-shader-compiler.json");
std::fs::write(
&manifest,
serde_json::json!({
"provides": ["shader.compile", "shader.compile.wgsl"],
"transports": {
"jsonrpc": "127.0.0.1:7777"
}
})
.to_string(),
)
.unwrap();
let result = read_capability_transport(&manifest, "shader.compile");
assert_eq!(result, Some("127.0.0.1:7777".to_owned()));
let result = read_capability_transport(&manifest, "nonexistent");
assert_eq!(result, None);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn read_capability_transport_legacy_capabilities_array() {
let dir = std::env::temp_dir().join("barracuda_test_discovery_legacy");
let _ = std::fs::create_dir_all(&dir);
let manifest = dir.join("legacy-compiler.json");
std::fs::write(
&manifest,
serde_json::json!({
"capabilities": ["shader_compiler"],
"transports": {
"jsonrpc": "127.0.0.1:8888"
}
})
.to_string(),
)
.unwrap();
let result = read_capability_transport(&manifest, "shader_compiler");
assert_eq!(result, Some("127.0.0.1:8888".to_owned()));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn constants_match_expected_values() {
assert_eq!(env_keys::DEFAULT_ECOSYSTEM_SOCKET_NAMESPACE, "biomeos");
assert_eq!(SHADER_CAPABILITY_SOCKET, "shader.sock");
assert_eq!(COMPILER_ADDR_ENV, "BARRACUDA_SHADER_COMPILER_ADDR");
assert_eq!(COMPILER_PORT_ENV, "BARRACUDA_SHADER_COMPILER_PORT");
}
#[tokio::test]
async fn discover_returns_none_without_env() {
let result = discover_shader_compiler().await;
if let Some(ref addr) = result {
assert!(!addr.is_empty());
}
}
#[tokio::test]
async fn discover_from_socket_does_not_panic() {
let _result = discover_from_socket().await;
}
}