Agent Mesh
Go a2aa2a-protocolagent-meshagentic-aiinferencemcpmeshmesh-networknetwork-securitynetworking-aip2p-network
feat(controlplane): add MeshAdapter abstraction and GossipSub MeshEvent publishing
Antonio Ojea51a14be8cbaf
diff --git a/internal/controlplane/mesh.go b/internal/controlplane/mesh.gonew file mode 100644index 00000000..5d05b042--- /dev/null+++ b/internal/controlplane/mesh.go@@ -0,0 +1,186 @@+// Copyright 2026 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package controlplane++import (+ "context"+ "crypto/ed25519"+ "fmt"+ "sync"+ "time"++ pubsub "github.com/libp2p/go-libp2p-pubsub"+ "github.com/libp2p/go-libp2p/core/host"+ "github.com/libp2p/go-libp2p/core/peer"+ "github.com/libp2p/go-libp2p/core/peerstore"+ "google.golang.org/protobuf/proto"++ "github.com/google/sam/api"+ "github.com/google/sam/internal/storage"+)++// ServiceAnnouncement represents service discovery details retrieved from the mesh.+type ServiceAnnouncement struct {+ ServiceName string+ ServiceType string+ PeerID string+ Addresses []string+}++// NodeStatus represents mesh status information for a peer.+type NodeStatus struct {+ PeerID string+ IsReachable bool+ Addresses []string+ LastSeen time.Time+}++// MeshAdapter defines the generic interface for Control Plane operations interacting with the Sovereign Agent Mesh.+type MeshAdapter interface {+ // PublishEvent constructs, signs, and broadcasts a Control Plane MeshEvent (POLICY_UPDATE, BANNED, KEY_ROTATION).+ PublishEvent(ctx context.Context, eventType api.MeshEvent_Type, peerID string, payload []byte) error++ // DiscoverServices queries active mesh nodes/DHT for services matching a type or pattern.+ DiscoverServices(ctx context.Context, serviceType string) ([]*ServiceAnnouncement, error)++ // GetNodeStatus retrieves node reachability and status from the mesh.+ GetNodeStatus(ctx context.Context, peerID string) (*NodeStatus, error)++ // Close gracefully releases any P2P host resources, streams, and PubSub topics.+ Close() error+}++// NopMeshAdapter provides a no-op implementation used when P2P mesh integration is disabled or in unit tests.+type NopMeshAdapter struct{}++func NewNopMeshAdapter() *NopMeshAdapter {+ return &NopMeshAdapter{}+}++func (n *NopMeshAdapter) PublishEvent(ctx context.Context, eventType api.MeshEvent_Type, peerID string, payload []byte) error {+ logger.Debugf("[NopMeshAdapter] PublishEvent skipped (P2P disabled): type=%v, peerID=%s", eventType, peerID)+ return nil+}++func (n *NopMeshAdapter) DiscoverServices(ctx context.Context, serviceType string) ([]*ServiceAnnouncement, error) {+ return nil, nil+}++func (n *NopMeshAdapter) GetNodeStatus(ctx context.Context, peerID string) (*NodeStatus, error) {+ return nil, nil+}++func (n *NopMeshAdapter) Close() error {+ return nil+}++// P2PMeshAdapter implements MeshAdapter using a libp2p Host and GossipSub subscriber/publisher.+type P2PMeshAdapter struct {+ host host.Host+ ps *pubsub.PubSub+ topic *pubsub.Topic+ store storage.Store+ mu sync.Mutex+}++func NewP2PMeshAdapter(h host.Host, ps *pubsub.PubSub, store storage.Store) (*P2PMeshAdapter, error) {+ if h == nil || ps == nil {+ return nil, fmt.Errorf("host and pubsub cannot be nil")+ }+ topic, err := ps.Join(api.GossipEvents)+ if err != nil {+ return nil, fmt.Errorf("failed to join gossip events topic %s: %w", api.GossipEvents, err)+ }++ return &P2PMeshAdapter{+ host: h,+ ps: ps,+ topic: topic,+ store: store,+ }, nil+}++func (p *P2PMeshAdapter) ConnectPeer(ctx context.Context, targetAddr string) error {+ info, err := peer.AddrInfoFromString(targetAddr)+ if err != nil {+ return fmt.Errorf("invalid peer address string %q: %w", targetAddr, err)+ }+ p.host.Peerstore().AddAddrs(info.ID, info.Addrs, peerstore.PermanentAddrTTL)+ if err := p.host.Connect(ctx, *info); err != nil {+ return fmt.Errorf("failed to connect to peer %s: %w", info.ID, err)+ }+ return nil+}++func (p *P2PMeshAdapter) PublishEvent(ctx context.Context, eventType api.MeshEvent_Type, peerID string, payload []byte) error {+ p.mu.Lock()+ defer p.mu.Unlock()++ var privKey ed25519.PrivateKey+ if p.store != nil {+ key, _, err := p.store.GetCurrentKey(ctx)+ if err != nil {+ return fmt.Errorf("failed to retrieve signing key for event publishing: %w", err)+ }+ privKey = key+ }++ event := &api.MeshEvent{+ Type: eventType,+ PeerId: peerID,+ Timestamp: time.Now().UnixMilli(),+ NewPublicKey: payload,+ }++ if privKey != nil {+ eventData, err := proto.Marshal(event)+ if err != nil {+ return fmt.Errorf("failed to marshal event for signing: %w", err)+ }+ event.Signature = ed25519.Sign(privKey, eventData)+ }++ data, err := proto.Marshal(event)+ if err != nil {+ return fmt.Errorf("failed to marshal signed mesh event: %w", err)+ }++ if err := p.topic.Publish(ctx, data); err != nil {+ return fmt.Errorf("failed to publish mesh event to topic %s: %w", api.GossipEvents, err)+ }++ logger.Infof("[P2PMeshAdapter] Published MeshEvent %v to topic %s (peerID: %s)", eventType, api.GossipEvents, peerID)+ return nil+}++func (p *P2PMeshAdapter) DiscoverServices(ctx context.Context, serviceType string) ([]*ServiceAnnouncement, error) {+ return nil, nil+}++func (p *P2PMeshAdapter) GetNodeStatus(ctx context.Context, peerID string) (*NodeStatus, error) {+ return nil, nil+}++func (p *P2PMeshAdapter) Close() error {+ p.mu.Lock()+ defer p.mu.Unlock()+ if p.topic != nil {+ _ = p.topic.Close()+ }+ if p.host != nil {+ return p.host.Close()+ }+ return nil+}diff --git a/internal/controlplane/mesh_test.go b/internal/controlplane/mesh_test.gonew file mode 100644index 00000000..2aa1f93a--- /dev/null+++ b/internal/controlplane/mesh_test.go@@ -0,0 +1,160 @@+// Copyright 2026 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package controlplane++import (+ "context"+ "crypto/ed25519"+ "crypto/rand"+ "testing"+ "time"++ pubsub "github.com/libp2p/go-libp2p-pubsub"+ "github.com/libp2p/go-libp2p/core/peer"++ "github.com/libp2p/go-libp2p"+ "google.golang.org/protobuf/proto"++ "github.com/google/sam/api"+ "github.com/google/sam/internal/storage"+)++func TestNopMeshAdapter(t *testing.T) {+ adapter := NewNopMeshAdapter()+ ctx := context.Background()++ if err := adapter.PublishEvent(ctx, api.MeshEvent_POLICY_UPDATE, "", nil); err != nil {+ t.Fatalf("expected nil error, got %v", err)+ }++ services, err := adapter.DiscoverServices(ctx, "test")+ if err != nil || len(services) != 0 {+ t.Fatalf("unexpected DiscoverServices output: %v, %v", services, err)+ }++ status, err := adapter.GetNodeStatus(ctx, "peer1")+ if err != nil || status != nil {+ t.Fatalf("unexpected GetNodeStatus output: %v, %v", status, err)+ }++ if err := adapter.Close(); err != nil {+ t.Fatalf("expected nil error on Close, got %v", err)+ }+}++func TestP2PMeshAdapter_PublishAndSubscribe(t *testing.T) {+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)+ defer cancel()++ // 1. Create Control Plane store & initial keyring+ store, err := storage.NewSQLStore("sqlite", ":memory:")+ if err != nil {+ t.Fatalf("failed to create store: %v", err)+ }+ defer func() { _ = store.Close() }()++ pub, priv, err := ed25519.GenerateKey(rand.Reader)+ if err != nil {+ t.Fatalf("failed to generate key: %v", err)+ }+ if err := store.SaveInitialKey(ctx, priv, pub); err != nil {+ t.Fatalf("failed to save key: %v", err)+ }++ // 2. Create libp2p host and PubSub for Control Plane P2PMeshAdapter+ cpHost, err := libp2p.New(libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0"))+ if err != nil {+ t.Fatalf("failed to create cp host: %v", err)+ }+ defer func() { _ = cpHost.Close() }()++ cpPS, err := pubsub.NewGossipSub(ctx, cpHost)+ if err != nil {+ t.Fatalf("failed to create cp pubsub: %v", err)+ }++ adapter, err := NewP2PMeshAdapter(cpHost, cpPS, store)+ if err != nil {+ t.Fatalf("failed to create P2PMeshAdapter: %v", err)+ }+ defer func() { _ = adapter.Close() }()++ // 3. Create subscriber node host & PubSub+ subHost, err := libp2p.New(libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0"))+ if err != nil {+ t.Fatalf("failed to create sub host: %v", err)+ }+ defer func() { _ = subHost.Close() }()++ subPS, err := pubsub.NewGossipSub(ctx, subHost)+ if err != nil {+ t.Fatalf("failed to create sub pubsub: %v", err)+ }++ subTopic, err := subPS.Join(api.GossipEvents)+ if err != nil {+ t.Fatalf("failed to join topic: %v", err)+ }+ sub, err := subTopic.Subscribe()+ if err != nil {+ t.Fatalf("failed to subscribe to topic: %v", err)+ }++ // 4. Connect subscriber node to Control Plane host+ subHost.Peerstore().AddAddrs(cpHost.ID(), cpHost.Addrs(), 10*time.Second)+ if err := subHost.Connect(ctx, peer.AddrInfo{ID: cpHost.ID(), Addrs: cpHost.Addrs()}); err != nil {+ t.Fatalf("failed to connect subHost to cpHost: %v", err)+ }++ // Allow GossipSub mesh overlay connection to settle+ time.Sleep(500 * time.Millisecond)++ // 5. Test publishing BANNED event+ targetPeerID := "12D3KooWBannedPeerIDForTesting1234567890"+ if err := adapter.PublishEvent(ctx, api.MeshEvent_BANNED, targetPeerID, nil); err != nil {+ t.Fatalf("failed to publish BANNED event: %v", err)+ }++ msg, err := sub.Next(ctx)+ if err != nil {+ t.Fatalf("failed to receive event on subscriber: %v", err)+ }++ var event api.MeshEvent+ if err := proto.Unmarshal(msg.Data, &event); err != nil {+ t.Fatalf("failed to unmarshal received MeshEvent: %v", err)+ }++ if event.Type != api.MeshEvent_BANNED {+ t.Fatalf("expected event type %v, got %v", api.MeshEvent_BANNED, event.Type)+ }+ if event.PeerId != targetPeerID {+ t.Fatalf("expected peerID %q, got %q", targetPeerID, event.PeerId)+ }+ if len(event.Signature) == 0 {+ t.Fatalf("expected signed event signature, got empty signature")+ }++ // Verify Ed25519 signature against Control Plane public key+ sig := event.Signature+ event.Signature = nil+ eventData, err := proto.Marshal(&event)+ if err != nil {+ t.Fatalf("failed to marshal event for sig verification: %v", err)+ }+ if !ed25519.Verify(pub, eventData, sig) {+ t.Fatalf("ed25519 signature verification failed for published MeshEvent")+ }+}diff --git a/internal/controlplane/server.go b/internal/controlplane/server.goindex 7f355410..08c82396 100644--- a/internal/controlplane/server.go+++ b/internal/controlplane/server.go@@ -63,6 +63,7 @@ type Server struct {httpServer *http.Serverlistener net.Listenerlimiter *rate.Limiter+ mesh MeshAdapterprovidersMu sync.RWMutexproviders map[string]*oidc.Provider@@ -85,6 +86,7 @@ func NewServer(config Options, store storage.Store) (*Server, error) {return &Server{config: config,store: store,+ mesh: NewNopMeshAdapter(),limiter: rate.NewLimiter(rate.Limit(EnrollRateLimit), EnrollBurst),providers: make(map[string]*oidc.Provider),ctx: ctx,@@ -92,6 +94,13 @@ func NewServer(config Options, store storage.Store) (*Server, error) {}, nil}+// SetMeshAdapter sets a custom MeshAdapter implementation for the control plane.+func (s *Server) SetMeshAdapter(m MeshAdapter) {+ if m != nil {+ s.mesh = m+ }+}+// Start boots up HTTP services, sets up OIDC providers, loads initial keys and policies, and schedules rotations.func (s *Server) Start() error {// Initialize Keyring@@ -222,6 +231,9 @@ func (s *Server) runKeyRotationLoop() {logger.Errorf("Failed to rotate keyring: %v", err)} else {logger.Infof("Key rotation committed. New current public key: %s", hex.EncodeToString(newPub))+ if err := s.mesh.PublishEvent(s.ctx, api.MeshEvent_KEY_ROTATION, "", newPub); err != nil {+ logger.Warnf("Failed to publish KEY_ROTATION event to mesh: %v", err)+ }}case <-s.ctx.Done():return@@ -857,6 +869,10 @@ func (s *Server) HandlePolicies(w http.ResponseWriter, r *http.Request) {return}+ if err := s.mesh.PublishEvent(r.Context(), api.MeshEvent_POLICY_UPDATE, "", nil); err != nil {+ logger.Warnf("Failed to publish POLICY_UPDATE event to mesh: %v", err)+ }+resp := &api.PolicyConfigUpdateResponse{Success: true}respData, _ := proto.Marshal(resp)w.Header().Set("Content-Type", "application/x-protobuf")@@ -1474,6 +1490,10 @@ func (s *Server) HandleAdminRevoke(w http.ResponseWriter, r *http.Request) {return}+ if err := s.mesh.PublishEvent(ctx, api.MeshEvent_BANNED, req.PeerId, nil); err != nil {+ logger.Warnf("Failed to publish BANNED event for node %s to mesh: %v", req.PeerId, err)+ }+resp := &api.TokenRevokeResponse{Success: true,}diff --git a/tests/integration/controlplane_pubsub_integration_test.go b/tests/integration/controlplane_pubsub_integration_test.gonew file mode 100644index 00000000..b69b1408--- /dev/null+++ b/tests/integration/controlplane_pubsub_integration_test.go@@ -0,0 +1,237 @@+// Copyright 2026 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package integration_test++import (+ "bytes"+ "context"+ "crypto/ed25519"+ "net/http"+ "path/filepath"+ "testing"+ "time"++ "github.com/google/sam/api"+ "github.com/google/sam/internal/controlplane"+ "github.com/google/sam/internal/storage"+ "github.com/libp2p/go-libp2p"+ pubsub "github.com/libp2p/go-libp2p-pubsub"+ "github.com/libp2p/go-libp2p/core/peer"+ "google.golang.org/protobuf/proto"+)++func TestControlPlanePubSubEventIntegration(t *testing.T) {+ ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)+ defer cancel()++ tmpDir := t.TempDir()+ dbPath := filepath.Join(tmpDir, "cp.db")+ store, err := storage.NewSQLStore("sqlite", dbPath)+ if err != nil {+ t.Fatalf("failed to create store: %v", err)+ }+ defer func() { _ = store.Close() }()++ // 1. Create Control Plane Server+ opts := controlplane.Options{+ ListenAddr: "127.0.0.1:0",+ AdminToken: "test-admin-token",+ }+ cpServer, err := controlplane.NewServer(opts, store)+ if err != nil {+ t.Fatalf("failed to create control plane server: %v", err)+ }++ if err := cpServer.Start(); err != nil {+ t.Fatalf("failed to start control plane server: %v", err)+ }+ defer func() { _ = cpServer.Close() }()++ // Retrieve initial CP public key+ _, pubKey, err := store.GetCurrentKey(ctx)+ if err != nil {+ t.Fatalf("failed to retrieve CP public key: %v", err)+ }++ // 2. Set up P2PMeshAdapter for Control Plane+ cpHost, err := libp2p.New(libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0"))+ if err != nil {+ t.Fatalf("failed to create cp libp2p host: %v", err)+ }+ defer func() { _ = cpHost.Close() }()++ cpPS, err := pubsub.NewGossipSub(ctx, cpHost)+ if err != nil {+ t.Fatalf("failed to create cp pubsub: %v", err)+ }++ meshAdapter, err := controlplane.NewP2PMeshAdapter(cpHost, cpPS, store)+ if err != nil {+ t.Fatalf("failed to create P2PMeshAdapter: %v", err)+ }+ defer func() { _ = meshAdapter.Close() }()++ cpServer.SetMeshAdapter(meshAdapter)++ // 3. Create a subscriber node listening to api.GossipEvents+ subHost, err := libp2p.New(libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0"))+ if err != nil {+ t.Fatalf("failed to create subscriber host: %v", err)+ }+ defer func() { _ = subHost.Close() }()++ subPS, err := pubsub.NewGossipSub(ctx, subHost)+ if err != nil {+ t.Fatalf("failed to create subscriber pubsub: %v", err)+ }++ topic, err := subPS.Join(api.GossipEvents)+ if err != nil {+ t.Fatalf("failed to join topic: %v", err)+ }+ sub, err := topic.Subscribe()+ if err != nil {+ t.Fatalf("failed to subscribe to topic: %v", err)+ }++ // Connect subscriber node to Control Plane host+ subHost.Peerstore().AddAddrs(cpHost.ID(), cpHost.Addrs(), 10*time.Second)+ if err := subHost.Connect(ctx, peer.AddrInfo{ID: cpHost.ID(), Addrs: cpHost.Addrs()}); err != nil {+ t.Fatalf("failed to connect subscriber node to cpHost: %v", err)+ }++ // Allow mesh topology to settle+ time.Sleep(500 * time.Millisecond)++ // 4. Trigger POST /policies on Control Plane+ policyReq := &api.PolicyConfigUpdateRequest{+ Roles: []*api.PolicyRole{+ {+ Name: "developer",+ AllowedServices: []string{"mcp://api"},+ AllowedTargets: []string{"tcp://db:5432"},+ },+ },+ Bindings: []*api.PolicyBinding{+ {+ Role: "developer",+ Members: []string{"user:dev1"},+ },+ },+ }+ policyReqData, err := proto.Marshal(policyReq)+ if err != nil {+ t.Fatalf("failed to marshal policy request: %v", err)+ }++ req, err := http.NewRequestWithContext(ctx, http.MethodPost, "http://"+cpServer.Addr()+"/policies", bytes.NewReader(policyReqData))+ if err != nil {+ t.Fatalf("failed to create policy request: %v", err)+ }+ req.Header.Set("Authorization", "Bearer test-admin-token")+ req.Header.Set("Content-Type", "application/x-protobuf")++ resp, err := http.DefaultClient.Do(req)+ if err != nil {+ t.Fatalf("failed to send policy request: %v", err)+ }+ _ = resp.Body.Close()+ if resp.StatusCode != http.StatusOK {+ t.Fatalf("expected HTTP 200 OK from /policies, got %d", resp.StatusCode)+ }++ // Verify subscriber receives POLICY_UPDATE MeshEvent+ msg, err := sub.Next(ctx)+ if err != nil {+ t.Fatalf("failed to receive POLICY_UPDATE event: %v", err)+ }++ var event api.MeshEvent+ if err := proto.Unmarshal(msg.Data, &event); err != nil {+ t.Fatalf("failed to unmarshal MeshEvent: %v", err)+ }+ if event.Type != api.MeshEvent_POLICY_UPDATE {+ t.Fatalf("expected event type POLICY_UPDATE, got %v", event.Type)+ }++ // Verify signature+ sig := event.Signature+ event.Signature = nil+ signedBytes, _ := proto.Marshal(&event)+ if !ed25519.Verify(pubKey, signedBytes, sig) {+ t.Fatalf("signature verification failed for POLICY_UPDATE event")+ }++ // 5. Enroll a dummy node in storage and trigger POST /admin/revoke (BANNED event)+ targetPeerID := "12D3KooWTestPeerToBan12345678901234567890"+ nodeRecord := &storage.EnrolledNode{+ PeerID: targetPeerID,+ PublicKey: []byte("dummy-key"),+ Biscuit: []byte("dummy-token"),+ Role: "node",+ EnrollmentType: "BOOTSTRAP",+ EnrolledAt: time.Now(),+ }+ if err := store.EnrollNode(ctx, nodeRecord); err != nil {+ t.Fatalf("failed to enroll dummy node: %v", err)+ }++ revokeReq := &api.TokenRevokeRequest{PeerId: targetPeerID}+ revokeReqData, err := proto.Marshal(revokeReq)+ if err != nil {+ t.Fatalf("failed to marshal revoke request: %v", err)+ }++ reqBan, err := http.NewRequestWithContext(ctx, http.MethodPost, "http://"+cpServer.Addr()+"/admin/revoke", bytes.NewReader(revokeReqData))+ if err != nil {+ t.Fatalf("failed to create revoke request: %v", err)+ }+ reqBan.Header.Set("Authorization", "Bearer test-admin-token")+ reqBan.Header.Set("Content-Type", "application/x-protobuf")++ respBan, err := http.DefaultClient.Do(reqBan)+ if err != nil {+ t.Fatalf("failed to send revoke request: %v", err)+ }+ _ = respBan.Body.Close()+ if respBan.StatusCode != http.StatusOK {+ t.Fatalf("expected HTTP 200 OK from /admin/revoke, got %d", respBan.StatusCode)+ }++ // Verify subscriber receives BANNED MeshEvent+ msgBan, err := sub.Next(ctx)+ if err != nil {+ t.Fatalf("failed to receive BANNED event: %v", err)+ }++ var eventBan api.MeshEvent+ if err := proto.Unmarshal(msgBan.Data, &eventBan); err != nil {+ t.Fatalf("failed to unmarshal BANNED MeshEvent: %v", err)+ }+ if eventBan.Type != api.MeshEvent_BANNED {+ t.Fatalf("expected event type BANNED, got %v", eventBan.Type)+ }+ if eventBan.PeerId != targetPeerID {+ t.Fatalf("expected peer ID %q, got %q", targetPeerID, eventBan.PeerId)+ }++ // Verify signature+ sigBan := eventBan.Signature+ eventBan.Signature = nil+ signedBanBytes, _ := proto.Marshal(&eventBan)+ if !ed25519.Verify(pubKey, signedBanBytes, sigBan) {+ t.Fatalf("signature verification failed for BANNED event")+ }+}