tawasuyu/brahman
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(sidecar): WIT al sidecar — módulos conscientes vivos

Browse Source 
Cierra el ciclo brahman-card-wit ↔ runtime: un módulo que tenga su
.wit lo parsea, lo manda en Hello, y aparece como "consciente" en el
broker y en brahman-status.

Cambios coordinados (un solo commit por la cadena de tipos):

- brahman-card::WitInterface deriva Serialize/Deserialize/Eq.
- brahman-handshake::Hello lleva wit: Option<WitInterface> (#[serde(default)]
  para tolerar Hellos antiguos en formato JSON aunque postcard exige
  presencia explícita).
- Server's register_session enruta a ResolvedCard::from_conscious cuando
  viene wit; from_agnostic cuando no.
- Client::connect queda como wrapper de connect_with(path, card,
  wit: Option<WitInterface>) — backward-compatible.
- Broker::register acepta Option<WitInterface> como tercer arg; BrokeredCard
  guarda el wit. 25 sitios de tests actualizados con `, None` (vía perl).
- brahman-sidecar::SidecarConfig.wit + helpers SidecarConfig::with_wit
  y spawn_conscious(card, wit). Log attached reporta conscious=true|false.
- brahman-status pretty-print con 🧠 + sección wit (package/world +
  imports + exports) por sesión consciente.
- Example nuevo presence-conscious: parsea protocol.wit y se presenta
  consciente.

Validación end-to-end manual:

  $ ente-zero &
  $ presence-conscious demo.conscious shared_wit/protocol.wit &
  $ brahman-status
  Sessions (1):
    01K... demo.conscious 🧠  lifecycle=Daemon
        wit: brahman:protocol@0.1.0 / module
             imports: types, handshake, lifecycle
             exports: run

Tests: 32/32 (broker 11 + card 8 + handshake codec+transport 2 + integ 7
+ admin 0 + card-wit 4). Workspace: 0 errores.

CHANGELOG.md actualizado.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Sergio
2026-05-08 17:22:48 +00:00
parent f4dc019004
commit 354f992c63
13 changed files with 257 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/core/brahman-broker/src/lib.rs
+41 -30
View File
@@ -30,7 +30,7 @@
use std::collections::BTreeMap;
use brahman_card::{Card, Flow, Lifecycle, Priority, TypeRef};
use brahman_card::{Card, Flow, Lifecycle, Priority, TypeRef, WitInterface};
use serde::{Deserialize, Serialize};
use ulid::Ulid;
@@ -68,10 +68,12 @@ pub struct BrokeredCard {
pub priority: Priority,
pub inputs: Vec<Flow>,
pub outputs: Vec<Flow>,
/// Interfaz WIT extraída si el módulo es "consciente"; `None` si agnóstico.
pub wit: Option<WitInterface>,
}
impl BrokeredCard {
fn from_card(session: SessionId, card: &Card) -> Self {
fn from_card(session: SessionId, card: &Card, wit: Option<WitInterface>) -> Self {
Self {
session,
label: card.label.clone(),
@@ -79,6 +81,7 @@ impl BrokeredCard {
priority: card.priority,
inputs: card.flow.input.clone(),
outputs: card.flow.output.clone(),
wit,
}
}
}
@@ -125,9 +128,17 @@ impl Broker {
}
}
/// Registra una Card. Devuelve `Some(prev)` si reemplazó una existente.
pub fn register(&mut self, session: SessionId, card: &Card) -> Option<BrokeredCard> {
self.cards.insert(session, BrokeredCard::from_card(session, card))
/// Registra una Card con su WIT opcional. Devuelve `Some(prev)` si
/// reemplazó una existente. Pasar `None` en `wit` indica módulo
/// agnóstico (sin contrato WIT extraído).
pub fn register(
&mut self,
session: SessionId,
card: &Card,
wit: Option<WitInterface>,
) -> Option<BrokeredCard> {
self.cards
.insert(session, BrokeredCard::from_card(session, card, wit))
}
/// Quita una Card por sesión.
@@ -351,8 +362,8 @@ mod tests {
);
let s_prod = Ulid::new();
let s_cons = Ulid::new();
b.register(s_prod, &producer);
b.register(s_cons, &consumer);
b.register(s_prod, &producer, None);
b.register(s_cons, &consumer, None);
let m = b.find_producer_for(s_cons, "query").expect("match");
assert_eq!(m.producer_label, "dht");
@@ -391,8 +402,8 @@ mod tests {
);
let s_prod = Ulid::new();
let s_cons = Ulid::new();
b.register(s_prod, &producer);
b.register(s_cons, &consumer);
b.register(s_prod, &producer, None);
b.register(s_cons, &consumer, None);
let m = b.find_producer_for(s_cons, "in").expect("match");
assert_eq!(m.via, MatchStrategy::Structural);
@@ -427,9 +438,9 @@ mod tests {
output: vec![],
},
);
b.register(Ulid::new(), &producer);
b.register(Ulid::new(), &producer, None);
let s_cons = Ulid::new();
b.register(s_cons, &consumer);
b.register(s_cons, &consumer, None);
assert!(b.find_producer_for(s_cons, "in").is_none());
}
@@ -477,10 +488,10 @@ mod tests {
output: vec![],
},
);
b.register(Ulid::new(), &p_struct);
b.register(Ulid::new(), &p_exact);
b.register(Ulid::new(), &p_struct, None);
b.register(Ulid::new(), &p_exact, None);
let s_cons = Ulid::new();
b.register(s_cons, &consumer);
b.register(s_cons, &consumer, None);
let m = b.find_producer_for(s_cons, "in").expect("match");
// El exact gana incluso si tiene priority igual: por estrategia.
@@ -516,10 +527,10 @@ mod tests {
output: vec![],
},
);
b.register(Ulid::new(), &p1);
b.register(Ulid::new(), &p2);
b.register(Ulid::new(), &p1, None);
b.register(Ulid::new(), &p2, None);
let s_cons = Ulid::new();
b.register(s_cons, &consumer);
b.register(s_cons, &consumer, None);
let m = b.find_producer_for(s_cons, "in").expect("match");
assert_eq!(m.producer_label, "dht-test");
@@ -545,9 +556,9 @@ mod tests {
output: vec![],
},
);
b.register(Ulid::new(), &p);
b.register(Ulid::new(), &p, None);
let s_cons = Ulid::new();
b.register(s_cons, &consumer);
b.register(s_cons, &consumer, None);
let m = b.find_producer_for(s_cons, "in").expect("match");
assert_eq!(m.producer_label, "real-dht");
@@ -581,10 +592,10 @@ mod tests {
output: vec![],
},
);
b.register(Ulid::new(), &p_low);
b.register(Ulid::new(), &p_high);
b.register(Ulid::new(), &p_low, None);
b.register(Ulid::new(), &p_high, None);
let s_cons = Ulid::new();
b.register(s_cons, &consumer);
b.register(s_cons, &consumer, None);
let m = b.find_producer_for(s_cons, "in").expect("match");
assert_eq!(m.producer_label, "a-dht"); // priority High > Low
@@ -617,10 +628,10 @@ mod tests {
output: vec![],
},
);
b.register(Ulid::new(), &p1);
b.register(Ulid::new(), &p2);
b.register(Ulid::new(), &p1, None);
b.register(Ulid::new(), &p2, None);
let s_cons = Ulid::new();
b.register(s_cons, &consumer);
b.register(s_cons, &consumer, None);
let m = b.find_producer_for(s_cons, "in").expect("match");
assert_eq!(m.producer_label, "a-dht"); // alfabético gana
@@ -646,9 +657,9 @@ mod tests {
},
);
let s_p = Ulid::new();
b.register(s_p, &p);
b.register(s_p, &p, None);
let s_c = Ulid::new();
b.register(s_c, &consumer);
b.register(s_c, &consumer, None);
assert!(b.find_producer_for(s_c, "in").is_some());
b.unregister(s_p);
@@ -667,7 +678,7 @@ mod tests {
},
);
let s = Ulid::new();
b.register(s, &same);
b.register(s, &same, None);
// Solo una Card registrada — no hay otra que produzca string.
assert!(b.find_producer_for(s, "in").is_none());
@@ -692,8 +703,8 @@ mod tests {
output: vec![flow("user-input", prim("string"), None)],
},
);
b.register(Ulid::new(), &dht);
b.register(Ulid::new(), &ui);
b.register(Ulid::new(), &dht, None);
b.register(Ulid::new(), &ui, None);
let matches = b.all_matches();
assert_eq!(matches.len(), 2);