Skip to content

Agent Mesh

feat(controlplane): add MeshAdapter abstraction and GossipSub MeshEvent publishing

Antonio Ojea51a14be8cbaf
diff --git a/internal/controlplane/mesh.go b/internal/controlplane/mesh.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 7f355410..08c82396 100644
--- a/internal/controlplane/server.go
+++ b/internal/controlplane/server.go
@@ -63,6 +63,7 @@ type Server struct {
httpServer *http.Server
listener net.Listener
limiter *rate.Limiter
+ mesh MeshAdapter
providersMu sync.RWMutex
providers 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.go
new file mode 100644
index 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")
+ }
+}