Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
55 changes: 37 additions & 18 deletions pkg/clients/consensus/clientlogic.go
Original file line number Diff line number Diff line change
Expand Up @@ -137,7 +137,7 @@ func (client *Client) runClientLogic() error {
}

// start event stream
blockStream := client.rpcClient.NewBlockStream(client.clientCtx, rpc.StreamBlockEvent|rpc.StreamFinalizedEvent|rpc.StreamExecutionPayloadEvent)
blockStream := client.rpcClient.NewBlockStream(client.clientCtx, rpc.StreamBlockEvent|rpc.StreamHeadEvent|rpc.StreamFinalizedEvent|rpc.StreamExecutionPayloadEvent)
defer blockStream.Close()

// process events
Expand Down Expand Up @@ -166,6 +166,14 @@ func (client *Client) runClientLogic() error {
}
}

case rpc.StreamHeadEvent:
if headEvent, ok := evt.Data.(*v1.HeadEvent); ok {
err := client.processHeadEvent(headEvent)
if err != nil {
client.logger.Warnf("failed processing head event: %v", err)
}
}

case rpc.StreamFinalizedEvent:
if finalizedEvent, ok := evt.Data.(*v1.FinalizedCheckpointEvent); ok {
err := client.processFinalizedEvent(finalizedEvent)
Expand Down Expand Up @@ -209,20 +217,27 @@ func (client *Client) runClientLogic() error {
}

func (client *Client) processBlockEvent(evt *v1.BlockEvent) error {
err := client.processBlock(evt.Block, evt.Slot, nil, "streamed")
_, err := client.processBlock(evt.Block, evt.Slot, nil, "streamed")
if err != nil {
return fmt.Errorf("could not process block: %v", err)
}

client.headMutex.Lock()
client.headSlot = evt.Slot
client.headRoot = evt.Block
client.headMutex.Unlock()
client.pool.resetHeadForkCache()

return nil
}

func (client *Client) processHeadEvent(evt *v1.HeadEvent) error {
block, err := client.processBlock(evt.Block, evt.Slot, nil, "head")
if err != nil {
return fmt.Errorf("could not process head block: %v", err)
}

client.setHead(block)

return nil
}

func (client *Client) processFinalizedEvent(evt *v1.FinalizedCheckpointEvent) error {
client.logger.Debugf("received finalization_checkpoint event: finalized %v [0x%x]", evt.Epoch, evt.Block)
return client.setFinalizedHead(evt.Epoch, evt.Block)
Expand Down Expand Up @@ -271,11 +286,13 @@ func (client *Client) pollClientHead() error {
return fmt.Errorf("could not find latest header")
}

err = client.processBlock(latestHeader.Root, latestHeader.Header.Message.Slot, latestHeader.Header, "polled")
block, err := client.processBlock(latestHeader.Root, latestHeader.Header.Message.Slot, latestHeader.Header, "polled")
if err != nil {
return fmt.Errorf("could not get process block: %v", err)
}

client.setHead(block)

finalityCheckpoint, err := client.rpcClient.GetFinalityCheckpoints(ctx)
if err != nil {
return fmt.Errorf("could not get finality checkpoint: %v", err)
Expand All @@ -284,10 +301,10 @@ func (client *Client) pollClientHead() error {
return client.setFinalizedHead(finalityCheckpoint.Finalized.Epoch, finalityCheckpoint.Finalized.Root)
}

func (client *Client) processBlock(root phase0.Root, slot phase0.Slot, header *phase0.SignedBeaconBlockHeader, source string) error {
func (client *Client) processBlock(root phase0.Root, slot phase0.Slot, header *phase0.SignedBeaconBlockHeader, source string) (*Block, error) {
cachedBlock, isNewBlock := client.pool.blockCache.AddBlock(root, slot)
if cachedBlock == nil {
return fmt.Errorf("could not add block to cache %v [0x%x]", slot, root)
return nil, fmt.Errorf("could not add block to cache %v [0x%x]", slot, root)
}

cachedBlock.SetSeenBy(client)
Expand All @@ -314,7 +331,7 @@ func (client *Client) processBlock(root phase0.Root, slot phase0.Slot, header *p
return header.Header, nil
})
if err != nil {
return err
return nil, err
}

loaded, err := cachedBlock.EnsureBlock(func() (*spec.VersionedSignedBeaconBlock, error) {
Expand All @@ -329,7 +346,7 @@ func (client *Client) processBlock(root phase0.Root, slot phase0.Slot, header *p
return block, nil
})
if err != nil {
return err
return nil, err
}

if loaded {
Expand All @@ -342,21 +359,23 @@ func (client *Client) processBlock(root phase0.Root, slot phase0.Slot, header *p
}
}

return cachedBlock, nil
}

func (client *Client) setHead(block *Block) {
client.headMutex.Lock()

if bytes.Equal(client.headRoot[:], root[:]) {
if bytes.Equal(client.headRoot[:], block.Root[:]) {
client.headMutex.Unlock()
return nil
return
}

client.headSlot = slot
client.headRoot = root
client.headSlot = block.Slot
client.headRoot = block.Root
client.headMutex.Unlock()

client.pool.resetHeadForkCache()
client.blockDispatcher.Fire(cachedBlock)

return nil
client.blockDispatcher.Fire(block)
}

func (client *Client) loadBlockPayload(cachedBlock *Block) {
Expand Down
243 changes: 243 additions & 0 deletions pkg/clients/consensus/clientlogic_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,243 @@
package consensus

import (
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"net/http/httptest"
"slices"
"strings"
"testing"
"time"

"github.com/ethpandaops/assertoor/pkg/clients/consensus/rpc"
v1 "github.com/ethpandaops/go-eth2-client/api/v1"
"github.com/ethpandaops/go-eth2-client/spec"
"github.com/ethpandaops/go-eth2-client/spec/phase0"
"github.com/sirupsen/logrus"
)

func TestClientTracksHeadEvents(t *testing.T) {
pool := newTestPool(t)
pool.blockCache.specs = &ChainSpec{SlotsPerEpoch: 8}
parent := cacheTestBlock(t, pool, 12, phase0.Root{1}, phase0.Root{})
oldHead := cacheTestBlock(t, pool, 13, phase0.Root{2}, parent.Root)
newHead := cacheTestBlock(t, pool, 13, phase0.Root{3}, parent.Root)
events := make(chan *v1.HeadEvent)
topics := make(chan []string, 1)
payloadReady := make(chan struct{})
ctx, cancel := context.WithCancel(t.Context())

server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
var data any

switch r.URL.Path {
case "/eth/v1/node/syncing":
data = &v1.SyncState{HeadSlot: oldHead.Slot}
case "/eth/v1/node/version":
data = map[string]string{"version": "Lighthouse/test"}
case "/eth/v1/beacon/headers/head":
data = &v1.BeaconBlockHeader{Root: oldHead.Root, Canonical: true, Header: oldHead.GetHeader()}
case "/eth/v1/beacon/states/head/finality_checkpoints":
data = &v1.Finality{
PreviousJustified: &phase0.Checkpoint{},
Justified: &phase0.Checkpoint{},
Finalized: &phase0.Checkpoint{},
}
case "/eth/v1/events":
requested := strings.Split(r.URL.Query().Get("topics"), ",")

w.Header().Set("Content-Type", "text/event-stream")
w.WriteHeader(http.StatusOK)

controller := http.NewResponseController(w)
if err := controller.Flush(); err != nil {
t.Error(err)
return
}

if slices.Contains(requested, "execution_payload_available") {
close(payloadReady)
<-r.Context().Done()

return
}

topics <- requested

for {
select {
case event := <-events:
encoded, err := json.Marshal(event)
if err != nil {
t.Error(err)
return
}

if _, err := fmt.Fprintf(w, "event: head\ndata: %s\n\n", encoded); err != nil {
t.Error(err)
return
}

if err := controller.Flush(); err != nil {
t.Error(err)
return
}
case <-r.Context().Done():
return
}
}
default:
t.Errorf("unexpected request: %s", r.URL.Path)
http.NotFound(w, r)

return
}

w.Header().Set("Content-Type", "application/json")

if err := json.NewEncoder(w).Encode(map[string]any{"data": data}); err != nil {
t.Error(err)
}
}))
t.Cleanup(server.Close)
t.Cleanup(cancel)

rpcClient, err := rpc.NewBeaconClient("test", server.URL, nil)
if err != nil {
t.Fatal(err)
}

if err := rpcClient.Initialize(ctx); err != nil {
t.Fatal(err)
}

client := &Client{pool: pool, clientCtx: ctx, rpcClient: rpcClient, logger: pool.logger.WithField("client", "test")}
subscription := client.SubscribeBlockEvent(4)
done := make(chan error, 1)

go func() { done <- client.runClientLogic() }()

t.Cleanup(func() {
cancel()

select {
case err := <-done:
if err != nil {
t.Error(err)
}
case <-time.After(5 * time.Second):
t.Error("client loop did not stop")
}
})

select {
case requested := <-topics:
if !slices.Contains(requested, "head") {
t.Fatalf("client subscribes to %v, want head events", requested)
}
case <-time.After(5 * time.Second):
t.Fatal("client did not subscribe to events")
}

awaitHead(t, subscription, oldHead)

select {
case <-payloadReady:
case <-time.After(5 * time.Second):
t.Fatal("client did not subscribe to payload events")
}

select {
case events <- &v1.HeadEvent{Slot: newHead.Slot, Block: newHead.Root}:
case <-time.After(5 * time.Second):
t.Fatal("could not send head event")
}

awaitHead(t, subscription, newHead)

if slot, root := client.GetLastHead(); slot != newHead.Slot || root != newHead.Root {
t.Fatalf("head is %d [%s], want %d [%s]", slot, root, newHead.Slot, newHead.Root)
}
}

func TestBlockEventDoesNotReplaceHead(t *testing.T) {
pool := newTestPool(t)
parent := cacheTestBlock(t, pool, 12, phase0.Root{1}, phase0.Root{})
head := cacheTestBlock(t, pool, 13, phase0.Root{2}, parent.Root)
side := cacheTestBlock(t, pool, 13, phase0.Root{3}, parent.Root)
client := &Client{
pool: pool,
logger: pool.logger.WithField("client", "test"),
headSlot: head.Slot,
headRoot: head.Root,
isOnline: true,
clientCtx: t.Context(),
}
peer := &Client{pool: pool, clientIdx: 1, headSlot: head.Slot, headRoot: head.Root, isOnline: true}
pool.clients = []*Client{client, peer}

if err := client.processBlockEvent(&v1.BlockEvent{Slot: side.Slot, Block: side.Root}); err != nil {
t.Fatal(err)
}

if slot, root := client.GetLastHead(); slot != head.Slot || root != head.Root {
t.Fatalf("block import changed head to %d [%s], want %d [%s]", slot, root, head.Slot, head.Root)
}

if seen := side.GetSeenBy(); len(seen) != 1 || seen[0] != client {
t.Fatal("side block was not recorded as seen by the client")
}

if forks := pool.GetHeadForks(1); len(forks) != 1 {
t.Fatalf("got %d forks after a side block import, want 1", len(forks))
}
}

func awaitHead(t *testing.T, subscription *Subscription[*Block], want *Block) {
t.Helper()

select {
case block := <-subscription.Channel():
if block.Root != want.Root || block.Slot != want.Slot {
t.Fatalf("published head is %d [%s], want %d [%s]", block.Slot, block.Root, want.Slot, want.Root)
}
case <-time.After(5 * time.Second):
t.Fatalf("head %d [%s] was not published", want.Slot, want.Root)
}
}

func newTestPool(t *testing.T) *Pool {
t.Helper()

logger := logrus.New()
logger.SetOutput(io.Discard)

pool, err := NewPool(t.Context(), &PoolConfig{FollowDistance: 64}, logger)
if err != nil {
t.Fatal(err)
}

return pool
}

func cacheTestBlock(t *testing.T, pool *Pool, slot phase0.Slot, root, parent phase0.Root) *Block {
t.Helper()

block, _ := pool.blockCache.AddBlock(root, slot)
if err := block.EnsureHeader(func() (*phase0.SignedBeaconBlockHeader, error) {
return &phase0.SignedBeaconBlockHeader{Message: &phase0.BeaconBlockHeader{Slot: slot, ParentRoot: parent}}, nil
}); err != nil {
t.Fatal(err)
}

if _, err := block.EnsureBlock(func() (*spec.VersionedSignedBeaconBlock, error) {
return &spec.VersionedSignedBeaconBlock{Version: spec.DataVersionPhase0}, nil
}); err != nil {
t.Fatal(err)
}

return block
}
3 changes: 2 additions & 1 deletion pkg/clients/consensus/rpc/eventstream/eventstream.go
Original file line number Diff line number Diff line change
Expand Up @@ -77,8 +77,9 @@ func SubscribeWithRequest(lastEventID string, request *http.Request) (*Stream, e
// SubscribeWith takes a http client and request providing customization over both headers and
// control over the http client settings (timeouts, tls, etc)
func SubscribeWith(lastEventID string, client *http.Client, request *http.Request) (*Stream, error) {
streamClient := *client
stream := &Stream{
c: client,
c: &streamClient,
req: request,
lastEventID: lastEventID,
retry: time.Millisecond * 3000,
Expand Down
Loading