Skip to content

Agent Mesh

get revocation working

Antonio Ojea21d6545d390e
diff --git a/cmd/sam-hub/admin.go b/cmd/sam-hub/admin.go
new file mode 100644
index 00000000..cff783e4
--- /dev/null
+++ b/cmd/sam-hub/admin.go
@@ -0,0 +1,64 @@
+// 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 main
+
+import (
+ "context"
+ "fmt"
+ "net/http"
+ "time"
+
+ "github.com/google/sam/api"
+)
+
+// HubAdmin defines the interface needed by admin handlers.
+type HubAdmin interface {
+ PublishEvent(ctx context.Context, event *api.MeshEvent) error
+}
+
+// handleBan returns a handler for the /admin/ban endpoint.
+func handleBan(admin HubAdmin) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ if r.Method != http.MethodPost {
+ http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+ return
+ }
+ peerID := r.URL.Query().Get("peer")
+ logger.Infof("[Admin API] Received ban request for peer: %s", peerID)
+
+ if peerID == "" {
+ http.Error(w, "Missing peer parameter", http.StatusBadRequest)
+ return
+ }
+
+ // Create MeshEvent_BANNED
+ event := &api.MeshEvent{
+ Type: api.MeshEvent_BANNED,
+ PeerId: peerID,
+ Timestamp: time.Now().Unix(),
+ }
+
+ logger.Infof("[Admin API] Publishing ban event for peer: %s", peerID)
+ if err := admin.PublishEvent(r.Context(), event); err != nil {
+ logger.Errorf("[Admin API] Failed to publish event: %v", err)
+ http.Error(w, fmt.Sprintf("Failed to publish event: %v", err), http.StatusInternalServerError)
+ return
+ }
+
+ logger.Infof("[Admin API] Successfully published ban event for peer: %s", peerID)
+ w.WriteHeader(http.StatusOK)
+ _, _ = fmt.Fprintf(w, "Published BANNED event for peer %s", peerID)
+ }
+}
diff --git a/cmd/sam-hub/admin_test.go b/cmd/sam-hub/admin_test.go
new file mode 100644
index 00000000..cc2fb1b1
--- /dev/null
+++ b/cmd/sam-hub/admin_test.go
@@ -0,0 +1,90 @@
+// 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 main
+
+import (
+ "context"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ "github.com/google/sam/api"
+)
+
+type mockHubAdmin struct {
+ publishedEvents []*api.MeshEvent
+ publishErr error
+}
+
+func (m *mockHubAdmin) PublishEvent(ctx context.Context, event *api.MeshEvent) error {
+ if m.publishErr != nil {
+ return m.publishErr
+ }
+ m.publishedEvents = append(m.publishedEvents, event)
+ return nil
+}
+
+func TestHandleBan(t *testing.T) {
+ mockAdmin := &mockHubAdmin{}
+ handler := handleBan(mockAdmin)
+
+ // Test valid request
+ req, err := http.NewRequest("POST", "/admin/ban?peer=test-peer-id", nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ rr := httptest.NewRecorder()
+ handler.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusOK {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusOK)
+ }
+
+ if len(mockAdmin.publishedEvents) != 1 {
+ t.Errorf("expected 1 published event, got %d", len(mockAdmin.publishedEvents))
+ }
+
+ event := mockAdmin.publishedEvents[0]
+ if event.Type != api.MeshEvent_BANNED {
+ t.Errorf("expected BANNED event, got %v", event.Type)
+ }
+ if event.PeerId != "test-peer-id" {
+ t.Errorf("expected peer ID test-peer-id, got %s", event.PeerId)
+ }
+
+ // Test invalid method
+ req, err = http.NewRequest("GET", "/admin/ban?peer=test-peer-id", nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ rr = httptest.NewRecorder()
+ handler.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusMethodNotAllowed {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusMethodNotAllowed)
+ }
+
+ // Test missing parameter
+ req, err = http.NewRequest("POST", "/admin/ban", nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ rr = httptest.NewRecorder()
+ handler.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusBadRequest {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusBadRequest)
+ }
+}
diff --git a/cmd/sam-hub/main.go b/cmd/sam-hub/main.go
index f3ee2b90..19b376f7 100644
--- a/cmd/sam-hub/main.go
+++ b/cmd/sam-hub/main.go
@@ -18,18 +18,14 @@ import (
"context"
"crypto/ed25519"
"crypto/tls"
+ "crypto/x509"
"encoding/hex"
- "encoding/json"
"fmt"
"net/http"
"os"
"strings"
"time"
- "github.com/libp2p/go-libp2p/core/peer"
- "github.com/multiformats/go-multiaddr"
- "go.etcd.io/bbolt"
-
"github.com/biscuit-auth/biscuit-go/v2"
"github.com/biscuit-auth/biscuit-go/v2/parser"
"github.com/coreos/go-oidc/v3/oidc"
@@ -75,6 +71,10 @@ var (
keyGracePeriod time.Duration
keysDBPath string
metricsAddr string
+ adminToken string
+ tlsCertFile string
+ tlsKeyFile string
+ tlsCAFile string
)
var logger = golog.Logger("sam-hub")
@@ -582,12 +582,23 @@ func (h *Hub) signEvent(event *api.MeshEvent) error {
return nil
}
+func (h *Hub) PublishEvent(ctx context.Context, event *api.MeshEvent) error {
+ if err := h.signEvent(event); err != nil {
+ return err
+ }
+ data, err := proto.Marshal(event)
+ if err != nil {
+ return err
+ }
+ return h.EventTopic.Publish(ctx, data)
+}
+
func main() {
rootCmd := &cobra.Command{
Use: "sam-hub",
Short: "Sovereign Agent Mesh - Multi-Transport Hub",
Run: func(cmd *cobra.Command, args []string) {
- ctx := context.Background()
+ ctx := cmd.Context()
// Initialize logging
if os.Getenv("LOG_FORMAT") == "json" {
@@ -621,9 +632,52 @@ func main() {
go func() {
mux := http.NewServeMux()
mux.Handle("/metrics", promhttp.Handler())
- logger.Infof("Starting metrics server on %s", metricsAddr)
- if err := http.ListenAndServe(metricsAddr, mux); err != nil {
- logger.Errorf("Metrics server failed: %v", err)
+ mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusOK)
+ _, _ = w.Write([]byte("ok"))
+ })
+
+ mux.HandleFunc("/admin/ban", func(w http.ResponseWriter, r *http.Request) {
+ if adminToken != "" {
+ authHeader := r.Header.Get("Authorization")
+ if authHeader != "Bearer "+adminToken {
+ http.Error(w, "Unauthorized", http.StatusUnauthorized)
+ return
+ }
+ }
+ handleBan(h)(w, r)
+ })
+
+ server := &http.Server{
+ Addr: metricsAddr,
+ Handler: mux,
+ }
+
+ // Configure TLS if requested
+ if tlsCertFile != "" && tlsKeyFile != "" {
+ tlsConfig := &tls.Config{}
+ if tlsCAFile != "" {
+ caCert, err := os.ReadFile(tlsCAFile)
+ if err != nil {
+ logger.Fatalf("Failed to read CA cert: %v", err)
+ }
+ caCertPool := x509.NewCertPool()
+ caCertPool.AppendCertsFromPEM(caCert)
+ tlsConfig.ClientCAs = caCertPool
+ tlsConfig.ClientAuth = tls.RequireAndVerifyClientCert
+ logger.Info("mTLS enabled for admin service")
+ }
+ server.TLSConfig = tlsConfig
+
+ logger.Infof("Starting HTTPS server on %s", metricsAddr)
+ if err := server.ListenAndServeTLS(tlsCertFile, tlsKeyFile); err != nil {
+ logger.Errorf("HTTPS server failed: %v", err)
+ }
+ } else {
+ logger.Infof("Starting HTTP server on %s", metricsAddr)
+ if err := server.ListenAndServe(); err != nil {
+ logger.Errorf("HTTP server failed: %v", err)
+ }
}
}()
@@ -632,7 +686,7 @@ func main() {
logger.Infof("PeerID: %s", h.Host.ID())
logger.Infof("Hub running on P2P transports only.")
- select {}
+ <-ctx.Done()
},
}
@@ -651,7 +705,11 @@ func main() {
rootCmd.Flags().DurationVar(&keyRotationInterval, "key-rotation-interval", 0, "Key rotation interval (e.g. 12h). 0 disables rotation.")
rootCmd.Flags().DurationVar(&keyGracePeriod, "key-grace-period", 24*time.Hour, "Key grace period for old keys (e.g. 24h).")
rootCmd.Flags().StringVar(&keysDBPath, "keys-db", "keys.db", "Path to BoltDB file for keys")
- rootCmd.Flags().StringVar(&metricsAddr, "metrics-addr", ":9090", "Address to listen on for Prometheus metrics")
+ rootCmd.PersistentFlags().StringVar(&metricsAddr, "metrics-addr", ":9090", "Address to listen on for Prometheus metrics")
+ rootCmd.PersistentFlags().StringVar(&adminToken, "admin-token", "", "Secret token for authorizing admin requests")
+ rootCmd.PersistentFlags().StringVar(&tlsCertFile, "tls-cert-file", "", "Path to TLS certificate for the server")
+ rootCmd.PersistentFlags().StringVar(&tlsKeyFile, "tls-key-file", "", "Path to TLS private key for the server")
+ rootCmd.PersistentFlags().StringVar(&tlsCAFile, "tls-ca-file", "", "Path to CA certificate to verify client certificates (enables mTLS)")
var peerToBan string
var banReason string
@@ -670,101 +728,57 @@ func main() {
logger.Fatal("Missing --peer flag")
}
- // 1. Open BoltDB and extract key
- db, err := bbolt.Open(keysDBPath, 0600, nil)
- if err != nil {
- logger.Fatal(err)
- }
- defer db.Close() // nolint:errcheck
-
- var kr KeyRing
- err = db.View(func(tx *bbolt.Tx) error {
- b := tx.Bucket([]byte("keyring"))
- data := b.Get([]byte("data"))
- if data == nil {
- return fmt.Errorf("keyring not found in DB")
- }
- return json.Unmarshal(data, &kr)
- })
- if err != nil {
- logger.Fatal(err)
- }
-
- privKey := ed25519.PrivateKey(kr.Current.Private)
-
- // 2. Create and sign MeshEvent_BANNED
- event := &api.MeshEvent{
- Type: api.MeshEvent_BANNED,
- PeerId: peerToBan,
- Timestamp: time.Now().Unix(),
+ targetAddr := metricsAddr
+ if strings.HasPrefix(targetAddr, ":") {
+ targetAddr = "localhost" + targetAddr
}
- event.Signature = nil
- data, err := proto.Marshal(event)
- if err != nil {
- logger.Fatal(err)
+ scheme := "http"
+ var tlsConfig *tls.Config
+ if tlsCertFile != "" || tlsCAFile != "" {
+ scheme = "https"
+ tlsConfig = &tls.Config{
+ InsecureSkipVerify: true, // For tests, usually self-signed
+ }
+ if tlsCAFile != "" {
+ caCert, err := os.ReadFile(tlsCAFile)
+ if err != nil {
+ logger.Fatalf("Failed to read CA cert: %v", err)
+ }
+ caCertPool := x509.NewCertPool()
+ caCertPool.AppendCertsFromPEM(caCert)
+ tlsConfig.RootCAs = caCertPool
+ tlsConfig.InsecureSkipVerify = false // Verify if CA is provided!
+ }
}
- event.Signature = ed25519.Sign(privKey, data)
- eventData, err := proto.Marshal(event)
- if err != nil {
- logger.Fatal(err)
+ client := &http.Client{
+ Transport: &http.Transport{
+ TLSClientConfig: tlsConfig,
+ },
}
- // 3. Initialize minimal libp2p host and pubsub
- ctx := context.Background()
- h, err := libp2p.New(
- libp2p.Transport(libp2pquic.NewTransport),
- libp2p.Transport(tcp.NewTCPTransport),
- libp2p.Security(libp2ptls.ID, libp2ptls.New),
- )
+ url := fmt.Sprintf("%s://%s/admin/ban?peer=%s", scheme, targetAddr, peerToBan)
+ req, err := http.NewRequest("POST", url, nil)
if err != nil {
- logger.Fatal(err)
+ logger.Fatalf("Failed to create request: %v", err)
}
- defer func() { _ = h.Close() }() // nolint:errcheck
- ps, err := pubsub.NewGossipSub(ctx, h)
- if err != nil {
- logger.Fatal(err)
+ if adminToken != "" {
+ req.Header.Set("Authorization", "Bearer "+adminToken)
}
- topic, err := ps.Join(api.GossipEvents)
+ resp, err := client.Do(req)
if err != nil {
- logger.Fatal(err)
+ logger.Fatalf("Failed to send ban request: %v", err)
}
+ defer func() { _ = resp.Body.Close() }()
- if connectAddr != "" {
- addr, err := multiaddr.NewMultiaddr(connectAddr)
- if err != nil {
- logger.Fatal(err)
- }
- addrInfo, err := peer.AddrInfoFromP2pAddr(addr)
- if err != nil {
- logger.Fatal(err)
- }
- if err := h.Connect(ctx, *addrInfo); err != nil {
- logger.Fatal(err)
- }
- logger.Infof("Connected to %s", connectAddr)
- } else {
- logger.Warn("No --connect address provided. Event might not be broadcasted if no peers are connected.")
- }
-
- // Wait for pubsub peers
- fmt.Println("Waiting for pubsub peers...")
- for i := 0; i < 60; i++ {
- peers := topic.ListPeers()
- if len(peers) > 0 {
- fmt.Printf("Found %d pubsub peers\n", len(peers))
- break
- }
- time.Sleep(500 * time.Millisecond)
+ if resp.StatusCode != http.StatusOK {
+ logger.Fatalf("Ban request failed: %s", resp.Status)
}
- if err := topic.Publish(ctx, eventData); err != nil {
- logger.Fatal(err)
- }
- logger.Infof("Published BANNED event for peer %s", peerToBan)
+ fmt.Printf("Published BANNED event for peer %s\n", peerToBan)
},
}
diff --git a/cmd/sam-node/gate.go b/cmd/sam-node/gate.go
index 8d1e3863..9c3411ed 100644
--- a/cmd/sam-node/gate.go
+++ b/cmd/sam-node/gate.go
@@ -95,7 +95,6 @@ func (n *SamNode) HandleMCPStream(s network.Stream) {
return nil, nil, fmt.Errorf("node not initialized")
}
n.mu.Lock()
- knownCount := len(n.knownPeers)
var knownPeers []string
for p := range n.knownPeers {
knownPeers = append(knownPeers, p)
@@ -103,10 +102,24 @@ func (n *SamNode) HandleMCPStream(s network.Stream) {
n.mu.Unlock()
peers := n.Host.Network().Peers()
+ var connectedPeers []string
+ for _, p := range peers {
+ connectedPeers = append(connectedPeers, p.String())
+ }
dhtSize := n.DHT.RoutingTable().Size()
-
- response := fmt.Sprintf("Known peers count: %d\nKnown peers list: %v\nConnected peers: %d\nDHT Routing Table size: %d\nHub Peer ID: %s", knownCount, knownPeers, len(peers), dhtSize, n.HubPeerID)
-
+
+ resData := map[string]any{
+ "known_peers": knownPeers,
+ "connected_peers": connectedPeers,
+ "dht_size": dhtSize,
+ "hub_peer_id": n.HubPeerID.String(),
+ }
+ responseBytes, err := json.Marshal(resData)
+ if err != nil {
+ return nil, nil, err
+ }
+ response := string(responseBytes)
+
return &mcp.CallToolResult{
Content: []mcp.Content{
&mcp.TextContent{Text: response},
diff --git a/cmd/sam-node/mcp.go b/cmd/sam-node/mcp.go
index f20f08dc..8472ffc4 100644
--- a/cmd/sam-node/mcp.go
+++ b/cmd/sam-node/mcp.go
@@ -137,7 +137,6 @@ func NewMCPHandler(node *SamNode) http.Handler {
return nil, nil, fmt.Errorf("node not initialized")
}
node.mu.Lock()
- knownCount := len(node.knownPeers)
var knownPeers []string
for p := range node.knownPeers {
knownPeers = append(knownPeers, p)
@@ -145,9 +144,23 @@ func NewMCPHandler(node *SamNode) http.Handler {
node.mu.Unlock()
peers := node.Host.Network().Peers()
+ var connectedPeers []string
+ for _, p := range peers {
+ connectedPeers = append(connectedPeers, p.String())
+ }
dhtSize := node.DHT.RoutingTable().Size()
- response := fmt.Sprintf("Known peers count: %d\nKnown peers list: %v\nConnected peers: %d\nDHT Routing Table size: %d\nHub Peer ID: %s", knownCount, knownPeers, len(peers), dhtSize, node.HubPeerID)
+ resData := map[string]any{
+ "known_peers": knownPeers,
+ "connected_peers": connectedPeers,
+ "dht_size": dhtSize,
+ "hub_peer_id": node.HubPeerID.String(),
+ }
+ responseBytes, err := json.Marshal(resData)
+ if err != nil {
+ return nil, nil, err
+ }
+ response := string(responseBytes)
return &mcp.CallToolResult{
Content: []mcp.Content{
diff --git a/cmd/sam-node/node.go b/cmd/sam-node/node.go
index 2648ac81..9382b0ed 100644
--- a/cmd/sam-node/node.go
+++ b/cmd/sam-node/node.go
@@ -29,7 +29,6 @@ import (
"github.com/google/sam/api"
lru "github.com/hashicorp/golang-lru/v2"
"github.com/libp2p/go-libp2p"
- "github.com/libp2p/go-libp2p/p2p/net/connmgr"
dht "github.com/libp2p/go-libp2p-kad-dht"
pubsub "github.com/libp2p/go-libp2p-pubsub"
"github.com/libp2p/go-libp2p/core/crypto"
@@ -39,6 +38,7 @@ import (
"github.com/libp2p/go-libp2p/core/protocol"
"github.com/libp2p/go-libp2p/p2p/discovery/routing"
"github.com/libp2p/go-libp2p/p2p/discovery/util"
+ "github.com/libp2p/go-libp2p/p2p/net/connmgr"
libp2ptls "github.com/libp2p/go-libp2p/p2p/security/tls"
libp2pquic "github.com/libp2p/go-libp2p/p2p/transport/quic"
"github.com/libp2p/go-libp2p/p2p/transport/tcp"
@@ -268,7 +268,9 @@ func (n *SamNode) listenForHubEvents(ctx context.Context) {
n.mu.Lock()
switch event.Type {
case api.MeshEvent_JOIN:
- n.knownPeers[event.PeerId] = true
+ if event.PeerId != n.Host.ID().String() {
+ n.knownPeers[event.PeerId] = true
+ }
logger.Infof("[Mesh Event] Peer joined: %s", event.PeerId)
case api.MeshEvent_EXIT:
delete(n.knownPeers, event.PeerId)
@@ -402,16 +404,17 @@ func (n *SamNode) startDiscovery(ctx context.Context, meshID string, interval ti
continue
}
n.mu.Lock()
- if !n.knownPeers[p.ID.String()] {
- n.knownPeers[p.ID.String()] = true
- logger.Infof("[Discovery] Found new peer via DHT: %s", p.ID)
+ n.knownPeers[p.ID.String()] = true
+ n.mu.Unlock()
+
+ if n.Host.Network().Connectedness(p.ID) != network.Connected {
+ logger.Infof("[Discovery] Found peer not connected via DHT: %s", p.ID)
go func(pi peer.AddrInfo) {
if err := n.Host.Connect(ctx, pi); err != nil {
logger.Errorf("[Discovery] Failed to connect to %s: %v", pi.ID, err)
}
}(p)
}
- n.mu.Unlock()
}
}
}
diff --git a/tests/e2e/lib/container_mesh.bash b/tests/e2e/lib/container_mesh.bash
index 29ad4326..c566dda6 100644
--- a/tests/e2e/lib/container_mesh.bash
+++ b/tests/e2e/lib/container_mesh.bash
@@ -140,9 +140,8 @@ sys.exit(1)
mesh_get_node_count_via_mcp() {
local idx="$1"
local output
- output="$(docker run --rm -v "${MESH_SOCKET_DIR}:/sockets" -v "$(pwd)/bin/mcp-client:/mcp-client" python:3.12 /mcp-client -socket "/sockets/node-${idx}.sock" 2>/dev/null)"
-
- echo "${output}" | grep "Known peers count:" | awk '{print $4}' | tr -d '\r'
+ output="$(timeout 15s docker run --rm -v "${MESH_SOCKET_DIR}:/sockets" -v "$(pwd)/bin/mcp-client:/mcp-client" python:3.12 /mcp-client -socket "/sockets/node-${idx}.sock" 2>/dev/null)"
+ echo "${output}" | jq '.known_peers | length'
}
mesh_wait_for_node_count() {
@@ -152,10 +151,11 @@ sys.exit(1)
local i
for ((i=0; i<timeout_s; i++)); do
local output
- output="$(docker run --rm -v "${MESH_SOCKET_DIR}:/sockets" -v "$(pwd)/bin/mcp-client:/mcp-client" python:3.12 /mcp-client -socket "/sockets/node-${idx}.sock" 2>/dev/null)"
+ output="$(timeout 15s docker run --rm -v "${MESH_SOCKET_DIR}:/sockets" -v "$(pwd)/bin/mcp-client:/mcp-client" python:3.12 /mcp-client -socket "/sockets/node-${idx}.sock" 2>/dev/null)"
+ echo "Node ${idx} get_mesh_info raw output: ${output}"
local count
- count="$(echo "${output}" | grep "Known peers count:" | awk '{print $4}' | tr -d '\r')"
- echo "Node ${idx} reported output: ${output}"
+ count="$(echo "${output}" | jq '.known_peers | length')"
+ echo "Node ${idx} reported known peers count: ${count}"
if [[ "${count}" -eq "${expected}" ]]; then
return 0
fi
@@ -164,6 +164,26 @@ sys.exit(1)
return 1
}
+ mesh_wait_for_peer_connection() {
+ local idx="$1"
+ local target_peer="$2"
+ local timeout_s="${3:-20}"
+ local i
+ for ((i=0; i<timeout_s; i++)); do
+ local output
+ output="$(timeout 15s docker run --rm -v "${MESH_SOCKET_DIR}:/sockets" -v "$(pwd)/bin/mcp-client:/mcp-client" python:3.12 /mcp-client -socket "/sockets/node-${idx}.sock" 2>/dev/null)"
+ echo "[$(date +%T)] Node ${idx} get_mesh_info raw output: ${output}"
+ local connected
+ connected="$(echo "${output}" | jq -r --arg peer "$target_peer" '.connected_peers | index($peer) != null')"
+ echo "[$(date +%T)] Node ${idx} connection to ${target_peer}: ${connected}"
+ if [[ "${connected}" == "true" ]]; then
+ return 0
+ fi
+ sleep 1
+ done
+ return 1
+ }
+
mesh_start_mock_oidc() {
local name="${MESH_PREFIX}-oidc"
docker run -d \
diff --git a/tests/e2e/policy.bats b/tests/e2e/policy.bats
index b706c5cb..297b8a47 100644
--- a/tests/e2e/policy.bats
+++ b/tests/e2e/policy.bats
@@ -117,8 +117,8 @@ EOF
--name "${name}" \
--network "${MESH_NETWORK}" \
--network-alias mock-oidc \
- python:3.12 \
- sh -lc "pip install pyjwt cryptography && ${cmd}" >/dev/null
+ sam-mock-oidc:local \
+ sh -c "${cmd}" >/dev/null
MESH_CONTAINERS+=("${name}")
mesh_wait_for_log "${name}" "Mock OIDC server ready" 30
diff --git a/tests/e2e/revocation_test.bats b/tests/e2e/revocation_test.bats
index 8e049914..818f86c6 100644
--- a/tests/e2e/revocation_test.bats
+++ b/tests/e2e/revocation_test.bats
@@ -37,7 +37,9 @@ teardown() {
--key "${hub_key}" \
--listen "/ip4/0.0.0.0/udp/4001/quic-v1" \
--listen "/ip4/0.0.0.0/tcp/4002" \
- --mesh "e2e-mesh" >/dev/null
+ --mesh "e2e-mesh" \
+ --admin-token "e2e-token" \
+ --log-level debug >/dev/null
MESH_CONTAINERS+=("${hub_name}")
mesh_wait_for_log "${hub_name}" "PeerID:" 20
@@ -47,35 +49,56 @@ teardown() {
echo "${hub_peer_id}" > "/tmp/${MESH_PREFIX}-hub-peer-id"
# Start Node 1
- run mesh_start_node 1 "--discovery-interval 100ms"
+ echo "[$(date +%T)] Starting Node 1"
+ run mesh_start_node 1 "--discovery-interval 100ms --log-level debug"
[[ "$status" -eq 0 ]]
local node1_name="${MESH_PREFIX}-node-1"
mesh_wait_for_log "${node1_name}" "SAM Node Online" 20
+ mesh_wait_for_mcp_ready 1 20
local node1_peer_id
- node1_peer_id=$(docker logs "${node1_name}" 2>&1 | grep -oE '12D3Koo[a-zA-Z0-9]+' | head -n 1)
+ node1_peer_id=$(docker logs "${node1_name}" 2>&1 | grep "PeerID:" | head -n 1 | awk '{print $2}' | tr -d '\r')
# Start Node 2
- run mesh_start_node 2 "--discovery-interval 100ms"
+ echo "[$(date +%T)] Starting Node 2"
+ run mesh_start_node 2 "--discovery-interval 100ms --log-level debug"
[[ "$status" -eq 0 ]]
local node2_name="${MESH_PREFIX}-node-2"
mesh_wait_for_log "${node2_name}" "SAM Node Online" 20
+ mesh_wait_for_mcp_ready 2 20
# Extract Node 2 Peer ID
local node2_peer_id
- node2_peer_id=$(docker logs "${node2_name}" 2>&1 | grep -oE '12D3Koo[a-zA-Z0-9]+' | head -n 1)
+ node2_peer_id=$(docker logs "${node2_name}" 2>&1 | grep "PeerID:" | head -n 1 | awk '{print $2}' | tr -d '\r')
[[ -n "${node2_peer_id}" ]]
- # Verify nodes are connected to each other or at least known
- # Wait for Node 1 to see 2 peers (Hub + Node 2)
- run mesh_wait_for_node_count 1 2 20
+ # Explicitly connect Node 1 to Node 2
+ echo "[$(date +%T)] Explicitly connecting Node 1 to Node 2"
+ local node2_addr="/dns4/sam-node-2/tcp/5002/p2p/${node2_peer_id}"
+ run docker run --rm -v "${MESH_SOCKET_DIR}:/sockets" -v "$(pwd)/bin/mcp-client:/mcp-client" python:3.12 /mcp-client -socket "/sockets/node-1.sock" -tool "connect_peer" -args "{\"peer_addr\":\"${node2_addr}\"}"
+ [[ "$status" -eq 0 ]]
+
+ # Verify Node 1 connects to Node 2
+ echo "[$(date +%T)] Waiting for connection"
+ run mesh_wait_for_peer_connection 1 "${node2_peer_id}" 20
+ if [[ "$status" -ne 0 ]]; then
+ echo "Node 1 logs:"
+ docker logs "${node1_name}"
+ echo "Node 2 logs:"
+ docker logs "${node2_name}"
+ fi
[[ "$status" -eq 0 ]]
# Publish ban event for Node 2
- run docker exec "${hub_name}" /sam-hub admin ban --peer "${node2_peer_id}" --connect "/ip4/127.0.0.1/tcp/4002"
+ echo "[$(date +%T)] Publishing ban event"
+ run docker exec "${hub_name}" /sam-hub admin ban --peer "${node2_peer_id}" --connect "/dns4/sam-hub/tcp/4002/p2p/${hub_peer_id}" --admin-token "e2e-token"
echo "admin ban output: $output"
[[ "$status" -eq 0 ]]
+ if [[ "$output" != *"Published BANNED event"* ]]; then
+ echo "Hub logs:"
+ docker logs "${hub_name}"
+ fi
[[ "$output" == *"Published BANNED event"* ]]
# Verify Node 1 receives the ban event and logs it
diff --git a/tests/integration/catalog_test.go b/tests/integration/catalog_test.go
index 4ffe995a..24a4dece 100644
--- a/tests/integration/catalog_test.go
+++ b/tests/integration/catalog_test.go
@@ -2,7 +2,7 @@ package integration_test
import (
"context"
- "fmt"
+ "encoding/json"
"net"
"net/http"
"os"
@@ -212,16 +212,15 @@ func TestCatalogRoutingAndFailover(t *testing.T) {
t.Logf("Poll result:\n%s", text)
- lines := strings.Split(text, "\n")
- for _, line := range lines {
- if strings.HasPrefix(line, "Connected peers: ") {
- var cp int
- _, err := fmt.Sscanf(line, "Connected peers: %d", &cp)
- if err == nil && cp >= 3 {
- connected = true
- break
- }
- }
+ var data map[string]any
+ if err := json.Unmarshal([]byte(text), &data); err != nil {
+ t.Logf("Failed to parse JSON: %v", err)
+ time.Sleep(2 * time.Second)
+ continue
+ }
+ connectedPeers, ok := data["connected_peers"].([]any)
+ if ok && len(connectedPeers) >= 3 {
+ connected = true
}
if connected {