jschoubben
3907ea0db0
The seams were there and nothing chose a side: serve, push, ask and build all opened the old bus's connection and declared over its channel, whatever MESH_BUS_NATS said. So the switch moved every host and left the control plane unable to follow — "this control plane has no MESH_BROKER_AMQP" with the new bus named and standing (2026-09-28). That was task 4.3 of design 28, still open. One place now decides: connectLink reads the switch, refuses both buses named at once, raises the new bus's streams and this controller's consumers when it is handed the inventory, and opens the link over whichever bus it is on. Every caller that sent a declaration or asked a tool through the old channel goes through the server's bus instead, which the new transport has and the channel is not. OverNats is that outbound: a declaration is a JetStream publish into the node's own subject, an event is announced on the subject its name derives to, a tool is request and reply on the module's tool subject.
74 lines
3.0 KiB
Go
74 lines
3.0 KiB
Go
package link
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/nats-io/nats.go"
|
|
|
|
"github.com/novox/mesh-controller/internal/broker"
|
|
)
|
|
|
|
// OverNats is the controller's outbound on the bus being built: the same three acts the other
|
|
// transport has, on the subjects the permissions were derived for (design 25). A declaration is a
|
|
// JetStream publish into NODES, where the node's own consumer waits for it; an event is announced on
|
|
// the subject its name derives to; a tool is asked by request and reply on the module's tool subject.
|
|
type OverNats struct{ JS *broker.JetStream }
|
|
|
|
// declareSubject is where one node's declaration lands — the NODES stream's subject for it, and the
|
|
// only subject that node's consumer delivers. The host subscribes exactly this.
|
|
func declareSubject(node string) string { return "mesh.node." + node + ".declare" }
|
|
|
|
func (b OverNats) PublishDeclaration(ctx context.Context, node string, body []byte) error {
|
|
publish, cancel := context.WithTimeout(ctx, 15*time.Second)
|
|
defer cancel()
|
|
if _, err := b.JS.Context().Publish(declareSubject(node), body, nats.Context(publish)); err != nil {
|
|
return fmt.Errorf("declaring to %s: %w", node, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (b OverNats) PublishEvent(ctx context.Context, key, source, node string, body []byte) error {
|
|
// The key is the subject: the controller's own events are named in full, and what a module
|
|
// emits is derived before it reaches here. Headers carry the envelope the other transport put
|
|
// in message properties (ADR 0042), so a consumer reads who and when without the payload.
|
|
msg := nats.NewMsg(key)
|
|
msg.Data = body
|
|
msg.Header.Set("x-source", source)
|
|
msg.Header.Set("x-node", node)
|
|
msg.Header.Set("x-time", time.Now().UTC().Format(time.RFC3339Nano))
|
|
if err := b.JS.Conn().PublishMsg(msg); err != nil {
|
|
return fmt.Errorf("announcing %s: %w", key, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (b OverNats) AskTool(ctx context.Context, module, tool string, args []byte, timeout time.Duration) ([]byte, error) {
|
|
ask, cancel := context.WithTimeout(ctx, timeout)
|
|
defer cancel()
|
|
reply, err := b.JS.Conn().RequestWithContext(ask, "mesh.mod."+module+".tool."+tool, args)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("asking %s.%s: %w", module, tool, err)
|
|
}
|
|
return reply.Data, nil
|
|
}
|
|
|
|
// ConnectNats is Connect for the bus being built: the controller's inbound and outbound over one
|
|
// JetStream connection the caller has already raised the streams on. Nothing is declared here —
|
|
// the streams and the controller's consumers are asserted by Raise, before anything is served.
|
|
func ConnectNats(js *broker.JetStream, enroller Enroller, listener Listener) *Server {
|
|
return &Server{
|
|
inbound: Nats(js),
|
|
bus: OverNats{JS: js},
|
|
js: js,
|
|
enroller: enroller,
|
|
listener: listener,
|
|
log: newLog(),
|
|
}
|
|
}
|
|
|
|
// Bus is the controller's outbound, whichever transport it connected over. Callers that send a
|
|
// declaration or ask a tool use this rather than the channel, which one transport does not have.
|
|
func (s *Server) Bus() Bus { return s.bus }
|