wip: use wal file to replay chain

gno.land/cmd/gnoland/start.go

@@ -254,6 +254,9 @@ func execStart(ctx context.Context, c *startCfg, io commands.IO) error {
 	if err != nil {
 		return fmt.Errorf("unable to create the Gnoland node, %w", err)
 	}
+	if err := gnoNode.ConsensusState().ReplayFile("./wal", false); err != nil {
+		return err
+	}
 
 	// Start the node (async)
 	if err := gnoNode.Start(); err != nil {

misc/walscan/walscan.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+
+	"github.com/gnolang/gno/tm2/pkg/amino"
+	"github.com/gnolang/gno/tm2/pkg/bft/wal"
+
+	// Amino, amino, why so peculiar?
+	_ "github.com/gnolang/gno/tm2/pkg/bft/consensus"
+)
+
+const (
+	maxWALSize = 1 << 20 // 1MB
+)
+
+func main() {
+	flag.Parse()
+
+	filename := flag.Arg(0)
+	if filename == "" {
+		log.Fatalf("usage: %s <FILE>\n", flag.CommandLine.Name())
+	}
+	f, err := os.Open(filename)
+	if err != nil {
+		log.Fatalf("error opening %q: %v", filename, err)
+	}
+	defer f.Close()
+
+	amino.RegisterPackage(amino.NewPackage("github.com/gnolang/gno/tm2/pkg/bft/wal", "wal", amino.GetCallersDirname()).WithTypes(
+		&wal.MetaMessage{}, "MetaMessage",
+		&wal.TimedWALMessage{}, "TimedMessage",
+	))
+
+	rd := wal.NewWALReader(f, maxWALSize)
+	for {
+		msg, meta, err := rd.ReadMessage()
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				return
+			}
+			log.Fatalf("reading wal message: %v", err)
+		}
+		switch {
+		case msg != nil:
+			x := any(msg)
+			fmt.Printf("%s\n", amino.MustMarshalJSON(&x))
+		case meta != nil:
+			x := any(meta)
+			fmt.Printf("%s\n", amino.MustMarshalJSON(&x))
+		default:
+			panic("msg == meta == nil")
+		}
+	}
+}

tm2/pkg/bft/consensus/replay_file.go

@@ -30,16 +30,21 @@
 	if cs.IsRunning() {
 		return errors.New("cs is already running, cannot replay")
 	}
-	if cs.wal != nil {
+	if cs.wal != nil && (cs.wal != walm.NopWAL{}) {
 		return errors.New("cs wal is open, cannot replay")
 	}
 
 	cs.startForReplay()
 
 	// ensure all new step events are regenerated as expected
 
-	newStepSub := events.SubscribeToEvent(cs.evsw, subscriber, cstypes.EventNewRoundStep{})
-	defer cs.evsw.RemoveListener(subscriber)
+	// XXX:
+	// This doesn't work synchronously (the default), and there seem to be tweaks
+	// to be made to make this work synchronously.
+	//
+	// ch := make(chan events.Event, 1) // asynchronous
+	// newStepSub := events.SubscribeToEventOn(cs.evsw, subscriber, cstypes.EventNewRoundStep{}, ch)
+	// defer cs.evsw.RemoveListener(subscriber)
 
 	// just open the file for reading, no need to use wal
 	fp, err := os.OpenFile(file, os.O_RDONLY, 0o600)
@@ -50,6 +55,8 @@
 	pb := newPlayback(file, fp, cs, cs.state.Copy())
 	defer pb.fp.Close() //nolint: errcheck
 
+	cs.Logger.Debug("Replay: playing back from file", "filename", file)
+
 	var nextN int // apply N msgs in a row
 	var msg *walm.TimedWALMessage
 	var meta *walm.MetaMessage
@@ -65,7 +72,7 @@
 			return err
 		}
 
-		if err := pb.cs.readReplayMessage(msg, meta, newStepSub); err != nil {
+		if err := pb.cs.readReplayMessage(msg, meta, nil); err != nil {
 			return err
 		}
 
@@ -142,18 +149,15 @@
 }
 
 func (cs *ConsensusState) startForReplay() {
-	cs.Logger.Error("Replay commands are disabled until someone updates them and writes tests")
-	/* TODO:!
-	// since we replay tocks we just ignore ticks
-		go func() {
-			for {
-				select {
-				case <-cs.tickChan:
-				case <-cs.Quit:
-					return
-				}
+	go func() {
+		for {
+			select {
+			//case <-cs.timeoutTicker.(*timeoutTicker).tickChan:
+			case <-cs.Quit():
+				return
 			}
-		}()*/
+		}
+	}()
 }
 
 // console function for parsing input and running commands
@@ -197,7 +201,8 @@
 
 			// ensure all new step events are regenerated as expected
 
-			newStepSub := events.SubscribeToEvent(pb.cs.evsw, subscriber, cstypes.EventNewRoundStep{})
+			ch := make(chan events.Event, 1) // asynchronous
+			newStepSub := events.SubscribeToEventOn(pb.cs.evsw, subscriber, cstypes.EventNewRoundStep{}, ch)
 			defer pb.cs.evsw.RemoveListener(subscriber)
 
 			if len(tokens) == 1 {