test(e2e): work in progress

Author: tzdybal

test/e2e/runner/perturb.go

@@ -108,12 +108,25 @@ func PerturbNode(ctx context.Context, node *e2e.Node, perturbation e2e.Perturbat
 		return nil, fmt.Errorf("unexpected perturbation %q", perturbation)
 	}
 
-	status, err := waitForNode(ctx, node, 0, 20*time.Second)
-	if err != nil {
-		return nil, err
+	if node.Mode == e2e.ModeSeed {
+		// Seed nodes don't have RPC, use simple wait
+		err = waitForSeedNode(ctx, node, 20*time.Second)
+		if err != nil {
+			return nil, err
+		}
+		logger.Info("perturb node",
+			"msg",
+			log.NewLazySprintf("Seed node %v recovered", node.Name))
+		return nil, nil // Return nil status for seed nodes since they don't have RPC
+	} else {
+		// Regular nodes use RPC status check
+		status, err := waitForNode(ctx, node, 0, 20*time.Second)
+		if err != nil {
+			return nil, err
+		}
+		logger.Info("perturb node",
+			"msg",
+			log.NewLazySprintf("Node %v recovered at height %v", node.Name, status.SyncInfo.LatestBlockHeight))
+		return status, nil
 	}
-	logger.Info("perturb node",
-		"msg",
-		log.NewLazySprintf("Node %v recovered at height %v", node.Name, status.SyncInfo.LatestBlockHeight))
-	return status, nil
 }

test/e2e/runner/rpc.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"net"
 	"time"
 
 	rpchttp "github.com/cometbft/cometbft/rpc/client/http"
@@ -132,3 +133,34 @@ func waitForAllNodes(ctx context.Context, testnet *e2e.Testnet, height int64, ti
 
 	return lastHeight, nil
 }
+
+// waitForSeedNode waits for a seed node's P2P port to become available.
+// Since seed nodes don't have RPC endpoints, we check P2P connectivity.
+func waitForSeedNode(ctx context.Context, node *e2e.Node, timeout time.Duration) error {
+	logger.Info("Waiting for seed node P2P port", "node", node.Name)
+
+	deadline := time.Now().Add(timeout)
+	ticker := time.NewTicker(500 * time.Millisecond)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-ticker.C:
+			if time.Now().After(deadline) {
+				return fmt.Errorf("timed out waiting for seed node %v P2P port after %v", node.Name, timeout)
+			}
+
+			// Try to connect to the P2P port
+			addr := node.AddressP2P(false)
+			conn, err := net.DialTimeout("tcp", addr, time.Second)
+			if err == nil && conn != nil {
+				conn.Close()
+				logger.Info("Seed node P2P port available", "node", node.Name, "addr", addr)
+				return nil
+			}
+			// Continue trying if connection failed
+		}
+	}
+}

test/e2e/runner/setup.go

@@ -227,6 +227,8 @@ func MakeConfig(node *e2e.Node) (*config.Config, error) {
 	case e2e.ModeSeed:
 		cfg.P2P.SeedMode = true
 		cfg.P2P.PexReactor = true
+		// Disable RPC for seed nodes as per ADR-052
+		cfg.RPC.ListenAddress = ""
 	case e2e.ModeFull, e2e.ModeLight:
 		// Don't need to do anything, since we're using a dummy privval key by default.
 	default:

test/e2e/runner/start.go

@@ -52,8 +52,16 @@ func Start(ctx context.Context, testnet *e2e.Testnet, p infra.Provider) error {
 		return err
 	}
 	for _, node := range nodesAtZero {
-		if _, err := waitForNode(ctx, node, 0, 15*time.Second); err != nil {
-			return err
+		if node.Mode == e2e.ModeSeed {
+			// Seed nodes don't have RPC, use simple wait
+			if err := waitForSeedNode(ctx, node, 15*time.Second); err != nil {
+				return err
+			}
+		} else {
+			// Regular nodes use RPC status check
+			if _, err := waitForNode(ctx, node, 0, 15*time.Second); err != nil {
+				return err
+			}
 		}
 		if node.PrometheusProxyPort > 0 {
 			logger.Info("start", "msg",
@@ -123,12 +131,23 @@ func Start(ctx context.Context, testnet *e2e.Testnet, p infra.Provider) error {
 		if err != nil {
 			return err
 		}
-		status, err := waitForNode(ctx, node, node.StartAt, 3*time.Minute)
-		if err != nil {
-			return err
+		if node.Mode == e2e.ModeSeed {
+			// Seed nodes don't have RPC, use simple wait
+			err = waitForSeedNode(ctx, node, 3*time.Minute)
+			if err != nil {
+				return err
+			}
+			logger.Info("start", "msg", log.NewLazySprintf("Seed node %v started",
+				node.Name))
+		} else {
+			// Regular nodes use RPC status check
+			status, err := waitForNode(ctx, node, node.StartAt, 3*time.Minute)
+			if err != nil {
+				return err
+			}
+			logger.Info("start", "msg", log.NewLazySprintf("Node %v up on http://%s:%v at height %v",
+				node.Name, node.ExternalIP, node.ProxyPort, status.SyncInfo.LatestBlockHeight))
 		}
-		logger.Info("start", "msg", log.NewLazySprintf("Node %v up on http://%s:%v at height %v",
-			node.Name, node.ExternalIP, node.ProxyPort, status.SyncInfo.LatestBlockHeight))
 	}
 
 	return nil