From 9265265c370aba3eca404fee00d78e9b02f6d5ce Mon Sep 17 00:00:00 2001 From: Thomas E Lackey Date: Fri, 23 Sep 2022 15:23:22 -0500 Subject: [PATCH] Add config file support for toggling block and state processing. --- cmd/boot.go | 3 +- cmd/full.go | 3 +- cmd/head.go | 3 +- cmd/historic.go | 3 +- ...xample.ipld-eth-beacon-indexer-config.json | 4 +- .../tel.ipld-eth-beacon-indexer-config.json | 40 ++++++++++ internal/boot/boot.go | 12 +-- internal/boot/boot_test.go | 46 +++++------ internal/shutdown/shutdown_test.go | 4 +- pkg/beaconclient/beaconclient.go | 11 +-- pkg/beaconclient/capturehead_test.go | 79 ++++++++----------- pkg/beaconclient/healthcheck_test.go | 5 +- 12 files changed, 125 insertions(+), 88 deletions(-) create mode 100644 config/tel.ipld-eth-beacon-indexer-config.json diff --git a/cmd/boot.go b/cmd/boot.go index 63e15b9..382e868 100644 --- a/cmd/boot.go +++ b/cmd/boot.go @@ -47,7 +47,8 @@ func bootApp() { Bc, Db, err := boot.BootApplicationWithRetry(ctx, viper.GetString("db.address"), viper.GetInt("db.port"), viper.GetString("db.name"), viper.GetString("db.username"), viper.GetString("db.password"), viper.GetString("db.driver"), viper.GetString("bc.address"), viper.GetInt("bc.port"), viper.GetString("bc.connectionProtocol"), viper.GetString("bc.type"), viper.GetInt("bc.bootRetryInterval"), viper.GetInt("bc.bootMaxRetry"), - viper.GetInt("kg.increment"), "boot", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb")) + viper.GetInt("kg.increment"), "boot", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb"), + viper.GetBool("bc.performBeaconBlockProcessing"), viper.GetBool("bc.performBeaconStateProcessing")) if err != nil { StopApplicationPreBoot(err, Db) } diff --git a/cmd/full.go b/cmd/full.go index 5a7fb1e..1f8a5e9 100644 --- a/cmd/full.go +++ b/cmd/full.go @@ -62,7 +62,8 @@ func startFullProcessing() { Bc, Db, err := boot.BootApplicationWithRetry(ctx, viper.GetString("db.address"), viper.GetInt("db.port"), viper.GetString("db.name"), viper.GetString("db.username"), viper.GetString("db.password"), viper.GetString("db.driver"), viper.GetString("bc.address"), viper.GetInt("bc.port"), viper.GetString("bc.connectionProtocol"), viper.GetString("bc.type"), viper.GetInt("bc.bootRetryInterval"), viper.GetInt("bc.bootMaxRetry"), - viper.GetInt("kg.increment"), "head", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb")) + viper.GetInt("kg.increment"), "head", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb"), + viper.GetBool("bc.performBeaconBlockProcessing"), viper.GetBool("bc.performBeaconStateProcessing")) if err != nil { StopApplicationPreBoot(err, Db) } diff --git a/cmd/head.go b/cmd/head.go index ba70f8c..e20cdda 100644 --- a/cmd/head.go +++ b/cmd/head.go @@ -50,7 +50,8 @@ func startHeadTracking() { Bc, Db, err := boot.BootApplicationWithRetry(ctx, viper.GetString("db.address"), viper.GetInt("db.port"), viper.GetString("db.name"), viper.GetString("db.username"), viper.GetString("db.password"), viper.GetString("db.driver"), viper.GetString("bc.address"), viper.GetInt("bc.port"), viper.GetString("bc.connectionProtocol"), viper.GetString("bc.type"), viper.GetInt("bc.bootRetryInterval"), viper.GetInt("bc.bootMaxRetry"), - viper.GetInt("kg.increment"), "head", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb")) + viper.GetInt("kg.increment"), "head", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb"), + viper.GetBool("bc.performBeaconBlockProcessing"), viper.GetBool("bc.performBeaconStateProcessing")) if err != nil { StopApplicationPreBoot(err, Db) } diff --git a/cmd/historic.go b/cmd/historic.go index 1c6b653..96c6004 100644 --- a/cmd/historic.go +++ b/cmd/historic.go @@ -50,7 +50,8 @@ func startHistoricProcessing() { Bc, Db, err := boot.BootApplicationWithRetry(ctx, viper.GetString("db.address"), viper.GetInt("db.port"), viper.GetString("db.name"), viper.GetString("db.username"), viper.GetString("db.password"), viper.GetString("db.driver"), viper.GetString("bc.address"), viper.GetInt("bc.port"), viper.GetString("bc.connectionProtocol"), viper.GetString("bc.type"), viper.GetInt("bc.bootRetryInterval"), viper.GetInt("bc.bootMaxRetry"), - viper.GetInt("kg.increment"), "historic", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb")) + viper.GetInt("kg.increment"), "historic", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb"), + viper.GetBool("bc.performBeaconBlockProcessing"), viper.GetBool("bc.performBeaconStateProcessing")) if err != nil { StopApplicationPreBoot(err, Db) } diff --git a/config/example.ipld-eth-beacon-indexer-config.json b/config/example.ipld-eth-beacon-indexer-config.json index 7481284..5e2909a 100644 --- a/config/example.ipld-eth-beacon-indexer-config.json +++ b/config/example.ipld-eth-beacon-indexer-config.json @@ -16,7 +16,9 @@ "maxHistoricProcessWorker": 2, "connectionProtocol": "http", "uniqueNodeIdentifier": 100, - "checkDb": true + "checkDb": true, + "performBeaconStateProcessing": false, + "performBeaconBlockProcessing": true }, "t": { "skipSync": true diff --git a/config/tel.ipld-eth-beacon-indexer-config.json b/config/tel.ipld-eth-beacon-indexer-config.json new file mode 100644 index 0000000..cbfa28e --- /dev/null +++ b/config/tel.ipld-eth-beacon-indexer-config.json @@ -0,0 +1,40 @@ +{ + "db": { + "address": "localhost", + "password": "secret12", + "port": 45432, + "username": "postgres", + "name": "postgres", + "driver": "PGX" + }, + "bc": { + "address": "localhost", + "port": 8001, + "type": "lighthouse", + "bootRetryInterval": 30, + "bootMaxRetry": 5, + "maxHistoricProcessWorker": 2, + "connectionProtocol": "http", + "uniqueNodeIdentifier": 100, + "checkDb": true + }, + "t": { + "skipSync": true + }, + "log": { + "level": "debug", + "output": true, + "file": "./ipld-eth-beacon-indexer.log", + "format": "json" + }, + "kg": { + "increment": 10000, + "processKnownGaps": true, + "maxKnownGapsWorker": 2 + }, + "pm": { + "address": "localhost", + "port": 9000, + "metrics": true + } +} diff --git a/internal/boot/boot.go b/internal/boot/boot.go index b407562..d57dade 100644 --- a/internal/boot/boot.go +++ b/internal/boot/boot.go @@ -42,11 +42,11 @@ var ( // // 3. Make sure the node is synced, unless disregardSync is true. func BootApplication(ctx context.Context, dbHostname string, dbPort int, dbName string, dbUsername string, dbPassword string, driverName string, - bcAddress string, bcPort int, bcConnectionProtocol string, bcKgTableIncrement int, disregardSync bool, uniqueNodeIdentifier int, checkDb bool) (*beaconclient.BeaconClient, sql.Database, error) { + bcAddress string, bcPort int, bcConnectionProtocol string, bcKgTableIncrement int, disregardSync bool, uniqueNodeIdentifier int, checkDb bool, performBeaconBlockProcessing bool, performBeaconStateProcessing bool) (*beaconclient.BeaconClient, sql.Database, error) { log.Info("Booting the Application") log.Debug("Creating the Beacon Client") - Bc, err := beaconclient.CreateBeaconClient(ctx, bcConnectionProtocol, bcAddress, bcPort, bcKgTableIncrement, uniqueNodeIdentifier, checkDb) + Bc, err := beaconclient.CreateBeaconClient(ctx, bcConnectionProtocol, bcAddress, bcPort, bcKgTableIncrement, uniqueNodeIdentifier, checkDb, performBeaconBlockProcessing, performBeaconStateProcessing) if err != nil { return Bc, nil, err } @@ -86,14 +86,15 @@ func BootApplication(ctx context.Context, dbHostname string, dbPort int, dbName // Add retry logic to ensure that we are give the Beacon Client and the DB time to start. func BootApplicationWithRetry(ctx context.Context, dbHostname string, dbPort int, dbName string, dbUsername string, dbPassword string, driverName string, bcAddress string, bcPort int, bcConnectionProtocol string, bcType string, bcRetryInterval int, bcMaxRetry int, bcKgTableIncrement int, - startUpMode string, disregardSync bool, uniqueNodeIdentifier int, checkDb bool) (*beaconclient.BeaconClient, sql.Database, error) { + startUpMode string, disregardSync bool, uniqueNodeIdentifier int, checkDb bool, performBeaconBlockProcessing bool, performBeaconStateProcessing bool) (*beaconclient.BeaconClient, sql.Database, error) { var err error if bcMaxRetry < 0 { i := 0 for { BC, DB, err = BootApplication(ctx, dbHostname, dbPort, dbName, dbUsername, dbPassword, driverName, - bcAddress, bcPort, bcConnectionProtocol, bcKgTableIncrement, disregardSync, uniqueNodeIdentifier, checkDb) + bcAddress, bcPort, bcConnectionProtocol, bcKgTableIncrement, disregardSync, uniqueNodeIdentifier, checkDb, + performBeaconBlockProcessing, performBeaconStateProcessing) if err != nil { log.WithFields(log.Fields{ "retryNumber": i, @@ -108,7 +109,8 @@ func BootApplicationWithRetry(ctx context.Context, dbHostname string, dbPort int } else { for i := 0; i < bcMaxRetry; i++ { BC, DB, err = BootApplication(ctx, dbHostname, dbPort, dbName, dbUsername, dbPassword, driverName, - bcAddress, bcPort, bcConnectionProtocol, bcKgTableIncrement, disregardSync, uniqueNodeIdentifier, checkDb) + bcAddress, bcPort, bcConnectionProtocol, bcKgTableIncrement, disregardSync, uniqueNodeIdentifier, checkDb, + performBeaconBlockProcessing, performBeaconStateProcessing) if err != nil { log.WithFields(log.Fields{ "retryNumber": i, diff --git a/internal/boot/boot_test.go b/internal/boot/boot_test.go index 8cb6977..8593087 100644 --- a/internal/boot/boot_test.go +++ b/internal/boot/boot_test.go @@ -25,66 +25,68 @@ import ( var _ = Describe("Boot", func() { var ( - dbAddress string = "localhost" - dbPort int = 8076 - dbName string = "vulcanize_testing" - dbUsername string = "vdbm" - dbPassword string = "password" - dbDriver string = "PGX" - bcAddress string = "localhost" - bcPort int = 5052 - bcConnectionProtocol string = "http" - bcType string = "lighthouse" - bcBootRetryInterval int = 1 - bcBootMaxRetry int = 5 - bcKgTableIncrement int = 10 - bcUniqueIdentifier int = 100 - bcCheckDb bool = false + dbAddress string = "localhost" + dbPort int = 8076 + dbName string = "vulcanize_testing" + dbUsername string = "vdbm" + dbPassword string = "password" + dbDriver string = "PGX" + bcAddress string = "localhost" + bcPort int = 5052 + bcConnectionProtocol string = "http" + bcType string = "lighthouse" + bcBootRetryInterval int = 1 + bcBootMaxRetry int = 5 + bcKgTableIncrement int = 10 + bcUniqueIdentifier int = 100 + bcCheckDb bool = false + bcProcessBeaconBlocks bool = true + bcProcessBeaconState bool = true ) Describe("Booting the application", Label("integration"), func() { Context("When the DB and BC are both up and running, we skip checking for a synced head, and we are processing head", func() { It("Should connect successfully", func() { - _, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", true, bcUniqueIdentifier, bcCheckDb) + _, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", true, bcUniqueIdentifier, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState) defer db.Close() Expect(err).ToNot(HaveOccurred()) }) }) Context("When the DB and BC are both up and running, we skip checking for a synced head, and we are processing historic ", func() { It("Should connect successfully", func() { - _, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "historic", true, bcUniqueIdentifier, bcCheckDb) + _, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "historic", true, bcUniqueIdentifier, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState) defer db.Close() Expect(err).ToNot(HaveOccurred()) }) }) Context("When the DB and BC are both up and running, and we check for a synced head", func() { It("Should not connect successfully", func() { - _, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", false, bcUniqueIdentifier, bcCheckDb) + _, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", false, bcUniqueIdentifier, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState) defer db.Close() Expect(err).To(HaveOccurred()) }) }) Context("When the DB and BC are both up and running, we skip checking for a synced head, but the unique identifier is 0", func() { It("Should not connect successfully", func() { - _, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", false, 0, bcCheckDb) + _, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", false, 0, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState) defer db.Close() Expect(err).To(HaveOccurred()) }) }) Context("When the DB is running but not the BC", func() { It("Should not connect successfully", func() { - _, _, err := boot.BootApplication(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, "hi", 100, bcConnectionProtocol, bcKgTableIncrement, true, bcUniqueIdentifier, bcCheckDb) + _, _, err := boot.BootApplication(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, "hi", 100, bcConnectionProtocol, bcKgTableIncrement, true, bcUniqueIdentifier, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState) Expect(err).To(HaveOccurred()) }) }) Context("When the BC is running but not the DB", func() { It("Should not connect successfully", func() { - _, _, err := boot.BootApplication(context.Background(), "hi", 10, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcKgTableIncrement, true, bcUniqueIdentifier, bcCheckDb) + _, _, err := boot.BootApplication(context.Background(), "hi", 10, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcKgTableIncrement, true, bcUniqueIdentifier, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState) Expect(err).To(HaveOccurred()) }) }) Context("When neither the BC or DB are running", func() { It("Should not connect successfully", func() { - _, _, err := boot.BootApplication(context.Background(), "hi", 10, dbName, dbUsername, dbPassword, dbDriver, "hi", 100, bcConnectionProtocol, bcKgTableIncrement, true, bcUniqueIdentifier, bcCheckDb) + _, _, err := boot.BootApplication(context.Background(), "hi", 10, dbName, dbUsername, dbPassword, dbDriver, "hi", 100, bcConnectionProtocol, bcKgTableIncrement, true, bcUniqueIdentifier, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState) Expect(err).To(HaveOccurred()) }) }) diff --git a/internal/shutdown/shutdown_test.go b/internal/shutdown/shutdown_test.go index cd86500..d076ab0 100644 --- a/internal/shutdown/shutdown_test.go +++ b/internal/shutdown/shutdown_test.go @@ -51,6 +51,8 @@ var ( bcKgTableIncrement int = 10 bcUniqueIdentifier int = 100 bcCheckDb bool = false + bcProcessBeaconBlocks bool = true + bcProcessBeaconState bool = true maxWaitSecondsShutdown time.Duration = time.Duration(1) * time.Second DB sql.Database BC *beaconclient.BeaconClient @@ -63,7 +65,7 @@ var _ = Describe("Shutdown", func() { BeforeEach(func() { ctx = context.Background() BC, DB, err = boot.BootApplicationWithRetry(ctx, dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, - bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", true, bcUniqueIdentifier, bcCheckDb) + bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", true, bcUniqueIdentifier, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState) notifierCh = make(chan os.Signal, 1) Expect(err).To(BeNil()) }) diff --git a/pkg/beaconclient/beaconclient.go b/pkg/beaconclient/beaconclient.go index d7337c4..af10c25 100644 --- a/pkg/beaconclient/beaconclient.go +++ b/pkg/beaconclient/beaconclient.go @@ -90,7 +90,8 @@ type SseError struct { } // A Function to create the BeaconClient. -func CreateBeaconClient(ctx context.Context, connectionProtocol string, bcAddress string, bcPort int, bcKgTableIncrement int, uniqueNodeIdentifier int, checkDb bool) (*BeaconClient, error) { +func CreateBeaconClient(ctx context.Context, connectionProtocol string, bcAddress string, bcPort int, + bcKgTableIncrement int, uniqueNodeIdentifier int, checkDb bool, performBeaconBlockProcessing bool, performBeaconStateProcessing bool) (*BeaconClient, error) { if uniqueNodeIdentifier == 0 { uniqueNodeIdentifier := rand.Int() log.WithField("randomUniqueNodeIdentifier", uniqueNodeIdentifier).Warn("No uniqueNodeIdentifier provided, we are going to use a randomly generated one.") @@ -112,8 +113,8 @@ func CreateBeaconClient(ctx context.Context, connectionProtocol string, bcAddres Metrics: metrics, UniqueNodeIdentifier: uniqueNodeIdentifier, CheckDb: checkDb, - PerformBeaconBlockProcessing: true, - PerformBeaconStateProcessing: false, + PerformBeaconBlockProcessing: performBeaconBlockProcessing, + PerformBeaconStateProcessing: performBeaconStateProcessing, //FinalizationTracking: createSseEvent[FinalizedCheckpoint](endpoint, bcFinalizedTopicEndpoint), }, nil } @@ -156,10 +157,10 @@ func (se *SseEvents[P]) initClient() { log.WithFields(log.Fields{"endpoint": se.Endpoint}).Info("Creating SSE client") client := sse.NewClient(se.Endpoint) client.ReconnectNotify = func(err error, duration time.Duration) { - log.WithFields(log.Fields{"endpoint": se.Endpoint}).Warn("Reconnecting SSE client") + log.WithFields(log.Fields{"endpoint": se.Endpoint}).Debug("Reconnecting SSE client") } client.OnDisconnect(func(c *sse.Client) { - log.WithFields(log.Fields{"endpoint": se.Endpoint}).Warn("SSE client disconnected") + log.WithFields(log.Fields{"endpoint": se.Endpoint}).Debug("SSE client disconnected") }) se.sseClient = client } diff --git a/pkg/beaconclient/capturehead_test.go b/pkg/beaconclient/capturehead_test.go index ec1fead..4ca4623 100644 --- a/pkg/beaconclient/capturehead_test.go +++ b/pkg/beaconclient/capturehead_test.go @@ -223,24 +223,6 @@ var ( SignedBeaconBlock: filepath.Join("ssz-data", "3797056", "should-not-exist.txt"), BeaconState: filepath.Join("ssz-data", "3797056", "beacon-state.ssz"), }, - "4636671": { - HeadMessage: beaconclient.Head{ - Slot: "4636671", - Block: "0xe7d4f3b7924c30ae047fceabb853b8afdae32b85e0a87ab6c4c37421b353a1da", - State: "0x66146a0bc8656a63aaf5dd357f327cac58c83fc90582ced82bebcc6e5f11855b", - CurrentDutyDependentRoot: "", - PreviousDutyDependentRoot: "", - EpochTransition: false, - ExecutionOptimistic: false, - }, - TestNotes: "The last Altair block", - SignedBeaconBlock: filepath.Join("ssz-data", "4636671", "signed-beacon-block.ssz"), - BeaconState: filepath.Join("ssz-data", "4636671", "beacon-state.ssz"), - CorrectEth1DataBlockHash: "0xa5b11e0cfb9ffd53e298f0d24fe07bc7a19ada6e52fa3f09397e1b34c07b4ec6", - CorrectParentRoot: "0x47fc3b7a28512a2570438c02bd0b96ebcac8bbcd97eed6d50f15454f37ac51b8", - CorrectSignedBeaconBlockMhKey: "", - CorrectBeaconStateMhKey: "", - }, "4636672": { HeadMessage: beaconclient.Head{ Slot: "4636672", @@ -288,19 +270,21 @@ var ( }, } TestConfig = Config{ - protocol: protocol, - address: address, - port: port, - dummyParentRoot: dummyParentRoot, - dbHost: dbHost, - dbPort: dbPort, - dbName: dbName, - dbUser: dbUser, - dbPassword: dbPassword, - dbDriver: dbDriver, - knownGapsTableIncrement: knownGapsTableIncrement, - bcUniqueIdentifier: bcUniqueIdentifier, - checkDb: true, + protocol: protocol, + address: address, + port: port, + dummyParentRoot: dummyParentRoot, + dbHost: dbHost, + dbPort: dbPort, + dbName: dbName, + dbUser: dbUser, + dbPassword: dbPassword, + dbDriver: dbDriver, + knownGapsTableIncrement: knownGapsTableIncrement, + bcUniqueIdentifier: bcUniqueIdentifier, + checkDb: true, + performBeaconStateProcessing: true, + performBeaconBlockProcessing: true, } BeaconNodeTester = TestBeaconNode{ @@ -541,19 +525,21 @@ var _ = Describe("Capturehead", Label("head"), func() { }) type Config struct { - protocol string - address string - port int - dummyParentRoot string - dbHost string - dbPort int - dbName string - dbUser string - dbPassword string - dbDriver string - knownGapsTableIncrement int - bcUniqueIdentifier int - checkDb bool + protocol string + address string + port int + dummyParentRoot string + dbHost string + dbPort int + dbName string + dbUser string + dbPassword string + dbDriver string + knownGapsTableIncrement int + bcUniqueIdentifier int + checkDb bool + performBeaconBlockProcessing bool + performBeaconStateProcessing bool } ////////////////////////////////////////////////////// @@ -563,7 +549,7 @@ type Config struct { // Must run before each test. We can't use the beforeEach because of the way // Gingko treats race conditions. func setUpTest(config Config, maxSlot string) *beaconclient.BeaconClient { - bc, err := beaconclient.CreateBeaconClient(context.Background(), config.protocol, config.address, config.port, config.knownGapsTableIncrement, config.bcUniqueIdentifier, config.checkDb) + bc, err := beaconclient.CreateBeaconClient(context.Background(), config.protocol, config.address, config.port, config.knownGapsTableIncrement, config.bcUniqueIdentifier, config.checkDb, config.performBeaconBlockProcessing, config.performBeaconStateProcessing) Expect(err).ToNot(HaveOccurred()) db, err := postgres.SetupPostgresDb(config.dbHost, config.dbPort, config.dbName, config.dbUser, config.dbPassword, config.dbDriver) Expect(err).ToNot(HaveOccurred()) @@ -611,12 +597,11 @@ func validateSignedBeaconBlock(bc *beaconclient.BeaconClient, headMessage beacon func validateBeaconState(bc *beaconclient.BeaconClient, headMessage beaconclient.Head, correctMhKey string) { dbSlot, stateRoot, mhKey := queryDbBeaconState(bc.Db, headMessage.Slot, headMessage.State) log.Info("validateBeaconState: ", headMessage) - baseSlot, err := strconv.Atoi(headMessage.Slot) + baseSlot, err := strconv.ParseUint(headMessage.Slot, 10, 64) Expect(err).ToNot(HaveOccurred()) Expect(dbSlot).To(Equal(baseSlot)) Expect(stateRoot).To(Equal(headMessage.State)) Expect(mhKey).To(Equal(correctMhKey)) - } // Wrapper function to send a head message to the beaconclient diff --git a/pkg/beaconclient/healthcheck_test.go b/pkg/beaconclient/healthcheck_test.go index b11b4cf..2afd28b 100644 --- a/pkg/beaconclient/healthcheck_test.go +++ b/pkg/beaconclient/healthcheck_test.go @@ -31,11 +31,10 @@ var _ = Describe("Healthcheck", func() { BeforeEach(func() { var err error - Bc, err = beaconclient.CreateBeaconClient(context.Background(), "http", "localhost", 8005, 10, bcUniqueIdentifier, false) + Bc, err = beaconclient.CreateBeaconClient(context.Background(), "http", "localhost", 8005, 10, bcUniqueIdentifier, false, true, true) Expect(err).ToNot(HaveOccurred()) - errBc, err = beaconclient.CreateBeaconClient(context.Background(), "http", "blah-blah", 1010, 10, bcUniqueIdentifier, false) + errBc, err = beaconclient.CreateBeaconClient(context.Background(), "http", "blah-blah", 1010, 10, bcUniqueIdentifier, false, true, true) Expect(err).ToNot(HaveOccurred()) - }) Describe("Connecting to the lighthouse client", Label("integration"), func() { Context("When the client is running", func() {