add cli flag for health check

Author: AL-CT

cmd/geth/config.go

@@ -260,6 +260,10 @@ func makeFullNode(ctx *cli.Context) *node.Node {
 		v := ctx.Uint64(utils.OverrideHvm0.Name)
 		cfg.Eth.OverrideHemiHvm0 = &v
 	}
+	if ctx.IsSet(utils.HealthDeucalionAddress.Name) {
+		v := ctx.String(utils.HealthDeucalionAddress.Name)
+		cfg.Eth.DeucalionAddress = v
+	}
 
 	// TODO: expose debug.verbosityFlag or pass verbosity setting up the stack
 	verbosity := ctx.Int("verbosity")

cmd/geth/main.go

@@ -173,6 +173,7 @@ var (
 		utils.TBCLevelDBHome,
 		utils.TBCBlockSanity,
 		utils.TBCNetwork,
+		utils.HealthDeucalionAddress,
 		utils.TBCPrometheusAddress,
 		utils.OverrideHvmEnabled,
 		utils.OverrideHvmGenesisHeader,

cmd/utils/flags.go

@@ -1002,6 +1002,12 @@ var (
 		Category: flags.RollupCategory,
 		Value:    "", // No Prometheus by default
 	}
+	HealthDeucalionAddress = &cli.StringFlag{
+		Name:     "hvm.deucalionaddress",
+		Usage:    "Deucalion address for health checks",
+		Category: flags.RollupCategory,
+		Value:    "", // No Deucalion by default
+	}
 	TBCSeeds = &cli.StringSliceFlag{
 		Name:     "tbc.seeds",
 		Usage:    "override tbc seeds when finding peers",

core/bench_test.go

@@ -17,6 +17,7 @@
 package core
 
 import (
+	"context"
 	"crypto/ecdsa"
 	"math/big"
 	"testing"
@@ -200,7 +201,7 @@ func benchInsertChain(b *testing.B, disk bool, gen func(int, *BlockGen)) {
 
 	// Time the insertion of the new chain.
 	// State and blocks are stored in the same DB.
-	chainman, _ := NewBlockChain(db, nil, gspec, nil, ethash.NewFaker(), vm.Config{}, nil)
+	chainman, _ := NewBlockChain(db, nil, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, nil, context.Background())
 	defer chainman.Stop()
 	b.ReportAllocs()
 	b.ResetTimer()
@@ -338,7 +339,7 @@ func benchReadChain(b *testing.B, full bool, count uint64) {
 		}
 		db = rawdb.NewDatabase(pdb)
 
-		chain, err := NewBlockChain(db, &cacheConfig, genesis, nil, ethash.NewFaker(), vm.Config{}, nil)
+		chain, err := NewBlockChain(db, &cacheConfig, genesis, nil, ethash.NewFaker(), vm.Config{}, nil, nil, context.Background())
 		if err != nil {
 			b.Fatalf("error creating chain: %v", err)
 		}

core/block_validator_test.go

@@ -17,6 +17,7 @@
 package core
 
 import (
+	"context"
 	"math/big"
 	"testing"
 	"time"
@@ -50,7 +51,7 @@ func testHeaderVerification(t *testing.T, scheme string) {
 		headers[i] = block.Header()
 	}
 	// Run the header checker for blocks one-by-one, checking for both valid and invalid nonces
-	chain, _ := NewBlockChain(rawdb.NewMemoryDatabase(), DefaultCacheConfigWithScheme(scheme), gspec, nil, ethash.NewFaker(), vm.Config{}, nil)
+	chain, _ := NewBlockChain(rawdb.NewMemoryDatabase(), DefaultCacheConfigWithScheme(scheme), gspec, nil, ethash.NewFaker(), vm.Config{}, nil, nil, context.Background())
 	defer chain.Stop()
 
 	for i := 0; i < len(blocks); i++ {
@@ -163,7 +164,7 @@ func testHeaderVerificationForMerging(t *testing.T, isClique bool) {
 		postHeaders[i] = block.Header()
 	}
 	// Run the header checker for blocks one-by-one, checking for both valid and invalid nonces
-	chain, _ := NewBlockChain(rawdb.NewMemoryDatabase(), nil, gspec, nil, engine, vm.Config{}, nil)
+	chain, _ := NewBlockChain(rawdb.NewMemoryDatabase(), nil, gspec, nil, engine, vm.Config{}, nil, nil, context.Background())
 	defer chain.Stop()
 
 	// Verify the blocks before the merging

core/blockchain.go

@@ -129,6 +129,9 @@ var (
 
 	emptyArray = [32]byte{}
 
+	// deucalion interval between progression check
+	progressionInterval = 15 * time.Second
+
 	// Special error thrown when blockchain state manipulation functions find that the external header mode TBC
 	// instance is in an impossible state implying data corruption or incrrect application of previous state trnsitions.
 	ErrExternalHeaderTBCInvalidState = errors.New("external header TBC instance is in an invalid state")
@@ -326,6 +329,7 @@ type BlockChain struct {
 	awaitingHvmSnapSync   bool
 	processingHvmSnapSync bool
 	finishedHvmSnapSync   bool
+	healthyNode           atomic.Bool
 
 	// Temporary workaround to allow restarting TBC Full Node when its not progressing
 	fullBlockFailureCount       uint32
@@ -560,36 +564,44 @@ func (bc *BlockChain) initHvmHeaderNode(config *tbc.Config) {
 	bc.hvmEnabled = true
 }
 
-const (
-	progressionInterval = 15 * time.Second
-	checkNumber         = 3
-)
-
-func (bc *BlockChain) SetupDeucalion(ctx context.Context) error {
+func (bc *BlockChain) SetupDeucalion(pctx context.Context, address string) error {
 	d, err := deucalion.New(&deucalion.Config{
-		ListenAddress: "localhost:8196",
+		ListenAddress: address,
 	})
-
 	if err != nil {
 		return err
 	}
 
+	ctx, cancel := context.WithCancel(pctx)
+
 	go func() {
+		defer cancel()
 		if err := d.Run(ctx, nil, func(ctx context.Context) (bool, any, error) {
-			oldHeader := bc.CurrentHeader()
-			for range checkNumber {
-				time.Sleep(progressionInterval)
+			return bc.healthyNode.Load(), bc.CurrentBlock(), nil
+		}); !errors.Is(err, context.Canceled) {
+			log.Error("deucalion terminated with error", "err", err)
+			return
+		}
+		log.Info("deucalion clean shutdown")
+	}()
+
+	go func() {
+		defer cancel()
+		oldHeader := bc.CurrentHeader()
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-time.After(progressionInterval):
 				curHeader := bc.CurrentHeader()
 				if curHeader.Number.Cmp(oldHeader.Number) <= 0 {
-					return false, nil, nil
+					bc.healthyNode.Store(false)
+				} else {
+					bc.healthyNode.Store(true)
 				}
+				oldHeader = curHeader
 			}
-			return true, nil, nil
-		}); !errors.Is(err, context.Canceled) {
-			log.Error("prometheus terminated with error", "err", err)
-			return
 		}
-		log.Info("prometheus clean shutdown")
 	}()
 
 	return nil
@@ -2120,7 +2132,7 @@ func (bc *BlockChain) GetBitcoinAttributesForNextBlock(timestamp uint64) (*types
 	if len(headersToAdd) > 8 {
 		headersToAdd = headersToAdd[0:8]
 	}
-	log.Info(fmt.Sprintf("Headers to add while generating Bitcoin Attributes Deposited transaction: %d", headersToAdd))
+	log.Info(fmt.Sprintf("Headers to add while generating Bitcoin Attributes Deposited transaction: %v", headersToAdd))
 
 	// Walk up headersToAdd, and truncate blocks that TBC Full Node does not have complete information for
 	for i := 0; i < len(headersToAdd); i++ {
@@ -2698,7 +2710,7 @@ func (bc *BlockChain) updateHvmHeaderConsensus(newHead *types.Header, updateFull
 	if currentHead == nil {
 		log.Error(fmt.Sprintf("currentHead is nil, but should have been %x", currentHeadHash[:]))
 	} else {
-		log.Debug(fmt.Sprintf("Going to look for ancestor of %d @ %s and %d @ %s", newHead.Hash().String(),
+		log.Debug(fmt.Sprintf("Going to look for ancestor of %s @ %d and %s @ %d", newHead.Hash().String(),
 			newHead.Number.Uint64(), currentHead.Hash().String(), currentHead.Number.Uint64()))
 	}
 

core/blockchain_repair_test.go

@@ -21,6 +21,7 @@
 package core
 
 import (
+	"context"
 	"math/big"
 	"path/filepath"
 	"testing"
@@ -1795,7 +1796,7 @@ func testRepairWithScheme(t *testing.T, tt *rewindTest, snapshots bool, scheme s
 		config.SnapshotLimit = 256
 		config.SnapshotWait = true
 	}
-	chain, err := NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil)
+	chain, err := NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to create chain: %v", err)
 	}
@@ -1860,7 +1861,7 @@ func testRepairWithScheme(t *testing.T, tt *rewindTest, snapshots bool, scheme s
 	}
 	defer db.Close()
 
-	newChain, err := NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil)
+	newChain, err := NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to recreate chain: %v", err)
 	}
@@ -1933,7 +1934,7 @@ func testIssue23496(t *testing.T, scheme string) {
 		}
 		engine = ethash.NewFullFaker()
 	)
-	chain, err := NewBlockChain(db, DefaultCacheConfigWithScheme(scheme), gspec, nil, engine, vm.Config{}, nil)
+	chain, err := NewBlockChain(db, DefaultCacheConfigWithScheme(scheme), gspec, nil, engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to create chain: %v", err)
 	}
@@ -1983,7 +1984,7 @@ func testIssue23496(t *testing.T, scheme string) {
 	}
 	defer db.Close()
 
-	chain, err = NewBlockChain(db, DefaultCacheConfigWithScheme(scheme), gspec, nil, engine, vm.Config{}, nil)
+	chain, err = NewBlockChain(db, DefaultCacheConfigWithScheme(scheme), gspec, nil, engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to recreate chain: %v", err)
 	}

core/blockchain_sethead_test.go

@@ -20,6 +20,7 @@
 package core
 
 import (
+	"context"
 	"fmt"
 	"math/big"
 	"path/filepath"
@@ -1998,7 +1999,7 @@ func testSetHeadWithScheme(t *testing.T, tt *rewindTest, snapshots bool, scheme
 		config.SnapshotLimit = 256
 		config.SnapshotWait = true
 	}
-	chain, err := NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil)
+	chain, err := NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to create chain: %v", err)
 	}

core/blockchain_snapshot_test.go

@@ -21,6 +21,7 @@ package core
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"math/big"
 	"os"
@@ -82,7 +83,7 @@ func (basic *snapshotTestBasic) prepare(t *testing.T) (*BlockChain, []*types.Blo
 		}
 		engine = ethash.NewFullFaker()
 	)
-	chain, err := NewBlockChain(db, DefaultCacheConfigWithScheme(basic.scheme), gspec, nil, engine, vm.Config{}, nil)
+	chain, err := NewBlockChain(db, DefaultCacheConfigWithScheme(basic.scheme), gspec, nil, engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to create chain: %v", err)
 	}
@@ -229,7 +230,7 @@ func (snaptest *snapshotTest) test(t *testing.T) {
 
 	// Restart the chain normally
 	chain.Stop()
-	newchain, err := NewBlockChain(snaptest.db, DefaultCacheConfigWithScheme(snaptest.scheme), snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil)
+	newchain, err := NewBlockChain(snaptest.db, DefaultCacheConfigWithScheme(snaptest.scheme), snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to recreate chain: %v", err)
 	}
@@ -271,13 +272,13 @@ func (snaptest *crashSnapshotTest) test(t *testing.T) {
 	// the crash, we do restart twice here: one after the crash and one
 	// after the normal stop. It's used to ensure the broken snapshot
 	// can be detected all the time.
-	newchain, err := NewBlockChain(newdb, DefaultCacheConfigWithScheme(snaptest.scheme), snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil)
+	newchain, err := NewBlockChain(newdb, DefaultCacheConfigWithScheme(snaptest.scheme), snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to recreate chain: %v", err)
 	}
 	newchain.Stop()
 
-	newchain, err = NewBlockChain(newdb, DefaultCacheConfigWithScheme(snaptest.scheme), snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil)
+	newchain, err = NewBlockChain(newdb, DefaultCacheConfigWithScheme(snaptest.scheme), snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to recreate chain: %v", err)
 	}
@@ -314,15 +315,15 @@ func (snaptest *gappedSnapshotTest) test(t *testing.T) {
 		SnapshotLimit:  0,
 		StateScheme:    snaptest.scheme,
 	}
-	newchain, err := NewBlockChain(snaptest.db, cacheConfig, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil)
+	newchain, err := NewBlockChain(snaptest.db, cacheConfig, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to recreate chain: %v", err)
 	}
 	newchain.InsertChain(gappedBlocks)
 	newchain.Stop()
 
 	// Restart the chain with enabling the snapshot
-	newchain, err = NewBlockChain(snaptest.db, DefaultCacheConfigWithScheme(snaptest.scheme), snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil)
+	newchain, err = NewBlockChain(snaptest.db, DefaultCacheConfigWithScheme(snaptest.scheme), snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to recreate chain: %v", err)
 	}
@@ -350,7 +351,7 @@ func (snaptest *setHeadSnapshotTest) test(t *testing.T) {
 	chain.SetHead(snaptest.setHead)
 	chain.Stop()
 
-	newchain, err := NewBlockChain(snaptest.db, DefaultCacheConfigWithScheme(snaptest.scheme), snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil)
+	newchain, err := NewBlockChain(snaptest.db, DefaultCacheConfigWithScheme(snaptest.scheme), snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to recreate chain: %v", err)
 	}
@@ -386,7 +387,7 @@ func (snaptest *wipeCrashSnapshotTest) test(t *testing.T) {
 		SnapshotLimit:  0,
 		StateScheme:    snaptest.scheme,
 	}
-	newchain, err := NewBlockChain(snaptest.db, config, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil)
+	newchain, err := NewBlockChain(snaptest.db, config, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to recreate chain: %v", err)
 	}
@@ -403,7 +404,7 @@ func (snaptest *wipeCrashSnapshotTest) test(t *testing.T) {
 		SnapshotWait:   false, // Don't wait rebuild
 		StateScheme:    snaptest.scheme,
 	}
-	tmp, err := NewBlockChain(snaptest.db, config, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil)
+	tmp, err := NewBlockChain(snaptest.db, config, snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to recreate chain: %v", err)
 	}
@@ -412,7 +413,7 @@ func (snaptest *wipeCrashSnapshotTest) test(t *testing.T) {
 	tmp.triedb.Close()
 	tmp.stopWithoutSaving()
 
-	newchain, err = NewBlockChain(snaptest.db, DefaultCacheConfigWithScheme(snaptest.scheme), snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil)
+	newchain, err = NewBlockChain(snaptest.db, DefaultCacheConfigWithScheme(snaptest.scheme), snaptest.gspec, nil, snaptest.engine, vm.Config{}, nil, nil, context.Background())
 	if err != nil {
 		t.Fatalf("Failed to recreate chain: %v", err)
 	}