github.com/vipernet-xyz/tm@v0.34.24/test/e2e/runner/start.go (about)

     1  package main
     2  
     3  import (
     4  	"fmt"
     5  	"sort"
     6  	"time"
     7  
     8  	"github.com/vipernet-xyz/tm/libs/log"
     9  	e2e "github.com/vipernet-xyz/tm/test/e2e/pkg"
    10  )
    11  
    12  func Start(testnet *e2e.Testnet) error {
    13  	if len(testnet.Nodes) == 0 {
    14  		return fmt.Errorf("no nodes in testnet")
    15  	}
    16  
    17  	// Nodes are already sorted by name. Sort them by name then startAt,
    18  	// which gives the overall order startAt, mode, name.
    19  	nodeQueue := testnet.Nodes
    20  	sort.SliceStable(nodeQueue, func(i, j int) bool {
    21  		a, b := nodeQueue[i], nodeQueue[j]
    22  		switch {
    23  		case a.Mode == b.Mode:
    24  			return false
    25  		case a.Mode == e2e.ModeSeed:
    26  			return true
    27  		case a.Mode == e2e.ModeValidator && b.Mode == e2e.ModeFull:
    28  			return true
    29  		}
    30  		return false
    31  	})
    32  
    33  	sort.SliceStable(nodeQueue, func(i, j int) bool {
    34  		return nodeQueue[i].StartAt < nodeQueue[j].StartAt
    35  	})
    36  
    37  	if nodeQueue[0].StartAt > 0 {
    38  		return fmt.Errorf("no initial nodes in testnet")
    39  	}
    40  
    41  	// Start initial nodes (StartAt: 0)
    42  	logger.Info("Starting initial network nodes...")
    43  	for len(nodeQueue) > 0 && nodeQueue[0].StartAt == 0 {
    44  		node := nodeQueue[0]
    45  		nodeQueue = nodeQueue[1:]
    46  		if err := execCompose(testnet.Dir, "up", "-d", node.Name); err != nil {
    47  			return err
    48  		}
    49  		if _, err := waitForNode(node, 0, 15*time.Second); err != nil {
    50  			return err
    51  		}
    52  		logger.Info("start", "msg", log.NewLazySprintf("Node %v up on http://127.0.0.1:%v", node.Name, node.ProxyPort))
    53  	}
    54  
    55  	networkHeight := testnet.InitialHeight
    56  
    57  	// Wait for initial height
    58  	logger.Info("Waiting for initial height",
    59  		"height", networkHeight,
    60  		"nodes", len(testnet.Nodes)-len(nodeQueue),
    61  		"pending", len(nodeQueue))
    62  
    63  	block, blockID, err := waitForHeight(testnet, networkHeight)
    64  	if err != nil {
    65  		return err
    66  	}
    67  
    68  	// Update any state sync nodes with a trusted height and hash
    69  	for _, node := range nodeQueue {
    70  		if node.StateSync || node.Mode == e2e.ModeLight {
    71  			err = UpdateConfigStateSync(node, block.Height, blockID.Hash.Bytes())
    72  			if err != nil {
    73  				return err
    74  			}
    75  		}
    76  	}
    77  
    78  	for _, node := range nodeQueue {
    79  		if node.StartAt > networkHeight {
    80  			// if we're starting a node that's ahead of
    81  			// the last known height of the network, then
    82  			// we should make sure that the rest of the
    83  			// network has reached at least the height
    84  			// that this node will start at before we
    85  			// start the node.
    86  
    87  			networkHeight = node.StartAt
    88  
    89  			logger.Info("Waiting for network to advance before starting catch up node",
    90  				"node", node.Name,
    91  				"height", networkHeight)
    92  
    93  			if _, _, err := waitForHeight(testnet, networkHeight); err != nil {
    94  				return err
    95  			}
    96  		}
    97  
    98  		logger.Info("Starting catch up node", "node", node.Name, "height", node.StartAt)
    99  
   100  		if err := execCompose(testnet.Dir, "up", "-d", node.Name); err != nil {
   101  			return err
   102  		}
   103  		status, err := waitForNode(node, node.StartAt, 3*time.Minute)
   104  		if err != nil {
   105  			return err
   106  		}
   107  		logger.Info("start", "msg", log.NewLazySprintf("Node %v up on http://127.0.0.1:%v at height %v",
   108  			node.Name, node.ProxyPort, status.SyncInfo.LatestBlockHeight))
   109  	}
   110  
   111  	return nil
   112  }