Skip to content

Agent Mesh

feat(sam-node): resolve /dnsaddr/ bootstrap multiaddresses and connect to all hub replicas

Antonio Ojeab8d3528e6181
diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.go
index 9427210c..2b72c720 100644
--- a/cmd/sam-node/node.go
+++ b/cmd/sam-node/node.go
@@ -58,6 +58,7 @@ import (
libp2ptls "github.com/libp2p/go-libp2p/p2p/security/tls"
"github.com/libp2p/go-msgio"
"github.com/multiformats/go-multiaddr"
+ madns "github.com/multiformats/go-multiaddr-dns"
"google.golang.org/protobuf/proto"
)
@@ -142,15 +143,39 @@ func (n *SamNode) UpdateRelays(addrs []multiaddr.Multiaddr) {
defer n.mu.Unlock()
var newRelays []peer.AddrInfo
for _, addr := range addrs {
- if addrInfo, err := peer.AddrInfoFromP2pAddr(addr); err == nil && addrInfo.ID != "" {
- newRelays = append(newRelays, *addrInfo)
- n.Host.Peerstore().AddAddrs(addrInfo.ID, addrInfo.Addrs, peerstore.PermanentAddrTTL)
+ resolvedAddrs, err := madns.DefaultResolver.Resolve(context.Background(), stripP2pFromDnsaddr(addr))
+ if err != nil {
+ resolvedAddrs = []multiaddr.Multiaddr{addr}
+ }
+ for _, resolved := range resolvedAddrs {
+ if addrInfo, err := peer.AddrInfoFromP2pAddr(resolved); err == nil && addrInfo.ID != "" {
+ newRelays = append(newRelays, *addrInfo)
+ n.Host.Peerstore().AddAddrs(addrInfo.ID, addrInfo.Addrs, peerstore.PermanentAddrTTL)
+ }
}
}
n.currentRelays = newRelays
logger.Infof("[Relay] Updated current relays for AutoRelay: %v", newRelays)
}
+func stripP2pFromDnsaddr(addr multiaddr.Multiaddr) multiaddr.Multiaddr {
+ _, err := addr.ValueForProtocol(multiaddr.P_DNSADDR)
+ if err != nil {
+ return addr
+ }
+ parts := multiaddr.Split(addr)
+ var components []multiaddr.Multiaddrer
+ for _, p := range parts {
+ if p.Protocol().Code != multiaddr.P_P2P {
+ components = append(components, multiaddr.Multiaddr{p})
+ }
+ }
+ if len(components) > 0 {
+ return multiaddr.Join(components...)
+ }
+ return addr
+}
+
// SamNodeConfig holds all configuration options for a SamNode.
type SamNodeConfig struct {
PrivKey crypto.PrivKey
@@ -216,15 +241,19 @@ func NewSamNode(ctx context.Context, cfg SamNodeConfig) (*SamNode, error) {
// Convert Hub multiaddrs to peer.AddrInfo to use as static relays
var staticRelays []peer.AddrInfo
for _, addr := range cfg.HubAddrs {
- if addrInfo, err := peer.AddrInfoFromP2pAddr(addr); err == nil && addrInfo.ID != "" {
- staticRelays = append(staticRelays, *addrInfo)
- if node.HubPeerID == "" {
- node.HubPeerID = addrInfo.ID
+ resolvedAddrs, err := madns.DefaultResolver.Resolve(ctx, stripP2pFromDnsaddr(addr))
+ if err != nil {
+ resolvedAddrs = []multiaddr.Multiaddr{addr}
+ }
+ for _, resolved := range resolvedAddrs {
+ if addrInfo, err := peer.AddrInfoFromP2pAddr(resolved); err == nil && addrInfo.ID != "" {
+ staticRelays = append(staticRelays, *addrInfo)
+ if node.HubPeerID == "" {
+ node.HubPeerID = addrInfo.ID
+ }
+ } else {
+ logger.Warnf("Failed to parse static relay addr %s: %v", resolved, err)
}
- // Permanently add the static relay address to the peerstore so we can build relay paths later
- // The node doesn't exist yet! We need to add it after New() returns.
- } else {
- logger.Warnf("Failed to parse static relay addr %s: %v", addr, err)
}
}
logger.Infof("Configured %d static relays: %v", len(staticRelays), staticRelays)
@@ -591,72 +620,109 @@ dhtLoop:
}
func (n *SamNode) ConnectAndAuthWithHub(ctx context.Context, addr multiaddr.Multiaddr) error {
- addrInfo, err := peer.AddrInfoFromP2pAddr(addr)
+ resolvedAddrs, err := madns.DefaultResolver.Resolve(ctx, stripP2pFromDnsaddr(addr))
if err != nil {
- return fmt.Errorf("failed to get AddrInfo from multiaddr: %w", err)
+ resolvedAddrs = []multiaddr.Multiaddr{addr}
}
- if err := n.Host.Connect(ctx, *addrInfo); err != nil {
- if strings.Contains(err.Error(), "peer id mismatch") {
- return fmt.Errorf("%w: %w", ErrFatalAuth, err)
+ var connected bool
+ var lastFatalErr error
+ var errs []error
+
+ for _, resolved := range resolvedAddrs {
+ addrInfo, err := peer.AddrInfoFromP2pAddr(resolved)
+ if err != nil {
+ errs = append(errs, fmt.Errorf("failed to get AddrInfo from multiaddr %s: %w", resolved, err))
+ continue
}
- return fmt.Errorf("failed to connect to hub %s: %w", addr, err)
- }
- n.HubPeerID = addrInfo.ID
- logger.Infof("[AuthN] Connected to hub: %s", addrInfo.ID)
+ if err := n.Host.Connect(ctx, *addrInfo); err != nil {
+ if strings.Contains(err.Error(), "peer id mismatch") {
+ lastFatalErr = fmt.Errorf("%w: %w", ErrFatalAuth, err)
+ }
+ errs = append(errs, fmt.Errorf("failed to connect to hub %s: %w", resolved, err))
+ continue
+ }
- // Load biscuit from store
- biscuitBytes, err := n.Store.LoadIdentity()
- if err != nil {
- return fmt.Errorf("%w: failed to load identity from store: %w", ErrFatalAuth, err)
+ // Load biscuit from store
+ biscuitBytes, err := n.Store.LoadIdentity()
+ if err != nil {
+ lastFatalErr = fmt.Errorf("%w: failed to load identity from store: %w", ErrFatalAuth, err)
+ errs = append(errs, lastFatalErr)
+ continue
+ }
+ if len(biscuitBytes) == 0 {
+ lastFatalErr = fmt.Errorf("%w: no identity biscuit found in store", ErrFatalAuth)
+ errs = append(errs, lastFatalErr)
+ continue
+ }
+
+ // Open auth stream
+ s, err := n.Host.NewStream(ctx, addrInfo.ID, api.AuthProtocolID)
+ if err != nil {
+ errs = append(errs, fmt.Errorf("failed to open auth stream to hub %s: %w", resolved, err))
+ continue
+ }
+
+ success, err := n.performHubAuthHandshake(s, biscuitBytes)
+ if err != nil {
+ _ = s.Close()
+ errs = append(errs, fmt.Errorf("handshake failed with hub %s: %w", resolved, err))
+ if errors.Is(err, ErrFatalAuth) {
+ lastFatalErr = err
+ }
+ continue
+ }
+ _ = s.Close()
+
+ if success {
+ n.HubPeerID = addrInfo.ID
+ logger.Infof("[AuthN] Successfully authenticated with hub via libp2p: %s", addrInfo.ID)
+ connected = true
+ }
}
- if len(biscuitBytes) == 0 {
- return fmt.Errorf("%w: no identity biscuit found in store", ErrFatalAuth)
+
+ if connected {
+ n.authOnce.Do(func() {
+ close(n.authSuccess)
+ })
+ return nil
}
- // Open auth stream
- s, err := n.Host.NewStream(ctx, addrInfo.ID, api.AuthProtocolID)
- if err != nil {
- return fmt.Errorf("failed to open auth stream to hub: %w", err)
+ if lastFatalErr != nil {
+ return lastFatalErr
}
- defer func() {
- if err := s.Close(); err != nil {
- logger.Debugf("failed to close stream: %v", err)
- }
- }()
+ return fmt.Errorf("failed to authenticate with any hub addresses: %w", errors.Join(errs...))
+}
+func (n *SamNode) performHubAuthHandshake(s network.Stream, biscuitBytes []byte) (bool, error) {
writer := msgio.NewVarintWriter(s)
authFrame := &api.AuthFrame{Biscuit: biscuitBytes}
data, err := proto.Marshal(authFrame)
if err != nil {
- return fmt.Errorf("failed to marshal auth frame: %w", err)
+ return false, fmt.Errorf("marshal auth frame: %w", err)
}
if err := writer.WriteMsg(data); err != nil {
- return fmt.Errorf("failed to write auth frame: %w", err)
+ return false, fmt.Errorf("write auth frame: %w", err)
}
reader := msgio.NewVarintReaderSize(s, 1024*64)
respMsg, err := reader.ReadMsg()
if err != nil {
- return fmt.Errorf("failed to read auth response: %w", err)
+ return false, fmt.Errorf("read auth response: %w", err)
}
defer reader.ReleaseMsg(respMsg)
var resp api.AuthResponse
if err := proto.Unmarshal(respMsg, &resp); err != nil {
- return fmt.Errorf("failed to unmarshal auth response: %w", err)
+ return false, fmt.Errorf("unmarshal auth response: %w", err)
}
if !resp.Success {
- return fmt.Errorf("%w: auth failed: %s", ErrFatalAuth, resp.Error)
+ return false, fmt.Errorf("%w: auth failed: %s", ErrFatalAuth, resp.Error)
}
- logger.Infof("[AuthN] Successfully authenticated with hub via libp2p")
- n.authOnce.Do(func() {
- close(n.authSuccess)
- })
- return nil
+ return true, nil
}
func (n *SamNode) StartRenewalLoop(ctx context.Context, issuerURL, clientID, clientSecret, jwtPath string) {
diff --git a/tests/integration/fallback_test.go b/tests/integration/fallback_test.go
index 3357a897..e3e06d81 100644
--- a/tests/integration/fallback_test.go
+++ b/tests/integration/fallback_test.go
@@ -482,7 +482,7 @@ func TestSelfHealingHTTPFallback(t *testing.T) {
mu.Unlock()
// Step 3: Start sam-node run
- runCmd := exec.Command(nodeBin, "run", "--trust-hub-rbac", "--listen", "/ip4/127.0.0.1/tcp/0")
+ runCmd := exec.Command(nodeBin, "run", "--trust-hub-rbac", "--listen", "/ip4/127.0.0.1/tcp/0", "--bind-addr", "127.0.0.1:0")
runCmd.Env = env
var stdout safeBuffer
runCmd.Stdout = &stdout