fix(advanced hardfork test): ensure cli command is called before network is shutdown

Author: glyh

src/app/hardfork_test/src/internal/hardfork/phases.go

@@ -11,13 +11,15 @@ import (
 	"time"
 )
 
+type HFHandler func(*HardforkTest, *BlockAnalysisResult) error
+
 // RunMainNetworkPhase runs the main network and validates its operation
 // and returns the fork config bytes and block analysis result
-func (t *HardforkTest) RunMainNetworkPhase(mainGenesisTs int64) ([]byte, *BlockAnalysisResult, error) {
+func (t *HardforkTest) RunMainNetworkPhase(mainGenesisTs int64, beforeShutdown HFHandler) (*BlockAnalysisResult, error) {
 	// Start the main network
 	mainNetCmd, err := t.RunMainNetwork(mainGenesisTs)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
 	defer t.gracefulShutdown(mainNetCmd, "Main network")
@@ -28,44 +30,42 @@ func (t *HardforkTest) RunMainNetworkPhase(mainGenesisTs int64) ([]byte, *BlockA
 	// Check block height at slot BestChainQueryFrom
 	blockHeight, err := t.Client.GetHeight(t.AnyPortOfType(PORT_REST))
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
 	t.Logger.Info("Block height is %d at slot %d.", blockHeight, t.Config.BestChainQueryFrom)
 
 	// Validate slot occupancy
 	if err := t.ValidateSlotOccupancy(0, blockHeight); err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
 	// Analyze blocks and get genesis epoch data
 	analysis, err := t.AnalyzeBlocks()
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
 	// Validate max slot
 	if err := t.ValidateLatestOccupiedSlot(analysis.LatestOccupiedSlot); err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
 	// Validate latest block slot
 	if err := t.ValidateLatestNonEmptyBlockSlot(analysis.LatestNonEmptyBlock); err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
 	// Validate no new blocks are created after chain end
 	if err := t.ValidateNoNewBlocks(t.AnyPortOfType(PORT_REST)); err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
-	// Extract fork config before nodes shutdown
-	forkConfigBytes, err := t.GetForkConfig(t.AnyPortOfType(PORT_REST))
-	if err != nil {
-		return nil, nil, err
+	if err := beforeShutdown(t, analysis); err != nil {
+		return nil, err
 	}
 
-	return forkConfigBytes, analysis, nil
+	return analysis, nil
 }
 
 type ForkData struct {
@@ -164,7 +164,7 @@ func (t *HardforkTest) LegacyForkPhase(analysis *BlockAnalysisResult, forkConfig
 }
 
 // Uses `mina advanced generate-hardfork-config CLI`
-func (t *HardforkTest) AdvancedForkPhase(analysis *BlockAnalysisResult, forkConfigBytes []byte) (*ForkData, error) {
+func (t *HardforkTest) AdvancedForkPhase(analysis *BlockAnalysisResult) (*ForkData, error) {
 
 	cwd := ""
 	var err error = nil

src/app/hardfork_test/src/internal/hardfork/test.go

@@ -118,31 +118,48 @@ func (t *HardforkTest) Run() error {
 
 	// Phase 1: Run and validate main network
 	t.Logger.Info("Phase 1: Running main network...")
-	forkConfigBytes, analysis, err := t.RunMainNetworkPhase(mainGenesisTs)
-	if err != nil {
-		return err
-	}
+	forkDataChan := make(chan ForkData, 1)
 
-	var forkData *ForkData
+	var beforeShutdown HFHandler
 	switch t.Config.ForkMethod {
 	case config.Legacy:
-		t.Logger.Info("Phase 2: Forking the legacy way...")
 
-		forkData, err = t.LegacyForkPhase(analysis, forkConfigBytes, mainGenesisTs)
-		if err != nil {
-			return err
+		beforeShutdown = func(t *HardforkTest, analysis *BlockAnalysisResult) error {
+			t.Logger.Info("Phase 2: Forking the legacy way...")
+
+			forkConfigBytes, err := t.GetForkConfig(t.AnyPortOfType(PORT_REST))
+			if err != nil {
+				return err
+			}
+			var forkData *ForkData
+			forkData, err = t.LegacyForkPhase(analysis, forkConfigBytes, mainGenesisTs)
+			if err != nil {
+				return err
+			}
+			forkDataChan <- *forkData
+			return nil
 		}
-	case config.Advanced:
-		t.Logger.Info("Phase 2: Forking with `mina advanced generate-hardfork-config`...")
 
-		forkData, err = t.AdvancedForkPhase(analysis, forkConfigBytes)
-		if err != nil {
-			return err
+	case config.Advanced:
+		beforeShutdown = func(t *HardforkTest, analysis *BlockAnalysisResult) error {
+			t.Logger.Info("Phase 2: Forking with `mina advanced generate-hardfork-config`...")
+
+			forkData, err := t.AdvancedForkPhase(analysis)
+			if err != nil {
+				return err
+			}
+			forkDataChan <- *forkData
+			return nil
 		}
 	}
 
+	analysis, err := t.RunMainNetworkPhase(mainGenesisTs, beforeShutdown)
+	if err != nil {
+		return err
+	}
+
 	t.Logger.Info("Phase 3: Running fork network...")
-	if err := t.RunForkNetworkPhase(analysis.LatestNonEmptyBlock.BlockHeight, *forkData, mainGenesisTs); err != nil {
+	if err := t.RunForkNetworkPhase(analysis.LatestNonEmptyBlock.BlockHeight, <-forkDataChan, mainGenesisTs); err != nil {
 		return err
 	}