[Consensus] add hotstuff view to ping route

Makefile

@@ -57,6 +57,7 @@ install-tools: crypto/relic/build check-go-version
 	cd ${GOPATH}; \
 	GO111MODULE=on go get github.com/golang/protobuf/protoc-gen-go@v1.3.2; \
 	GO111MODULE=on go get github.com/uber/prototool/cmd/prototool@v1.9.0; \
+	GO111MODULE=on go get github.com/gogo/protobuf/protoc-gen-gofast; \
 	GO111MODULE=on go get github.com/vektra/mockery/cmd/mockery@v1.1.2; \
 	GO111MODULE=on go get github.com/golang/mock/mockgen@v1.3.1; \
 	GO111MODULE=on go get golang.org/x/tools/cmd/stringer@master;

cmd/scaffold.go

@@ -23,6 +23,7 @@ import (
 
 	"github.com/onflow/flow-go/admin"
 	"github.com/onflow/flow-go/cmd/build"
+	"github.com/onflow/flow-go/consensus/hotstuff/persister"
 	"github.com/onflow/flow-go/fvm"
 	"github.com/onflow/flow-go/model/bootstrap"
 	"github.com/onflow/flow-go/model/flow"
@@ -173,6 +174,21 @@ func (fnb *FlowNodeBuilder) EnqueueNetworkInit(ctx context.Context) {
 			},
 		}
 
+		// only consensus roles will need to report hotstuff view
+		if fnb.BaseConfig.NodeRole == flow.RoleConsensus.String() {
+			// initialize the persister
+			persist := persister.New(node.DB, node.RootChainID)
+
+			pingProvider.HotstuffViewFun = func() (uint64, error) {
+				curView, err := persist.GetStarted()
+				if err != nil {
+					return 0, err
+				}
+
+				return curView, nil
+			}
+		}
+
 		libP2PNodeFactory, err := p2p.DefaultLibP2PNodeFactory(ctx,
 			fnb.Logger.Level(zerolog.ErrorLevel),
 			fnb.Me.NodeID(),

engine/access/ping/engine.go

@@ -124,6 +124,6 @@ func (e *Engine) pingNode(peer *flow.Identity) {
 
 	// if ping succeeded then update the node info metric
 	if pingErr == nil {
-		e.metrics.NodeInfo(peer, info, resp.Version, resp.BlockHeight)
+		e.metrics.NodeInfo(peer, info, resp.Version, resp.BlockHeight, resp.HotstuffView)
 	}
 }

integration/localnet/Makefile

@@ -47,8 +47,8 @@ init-short-epochs:
 
 .PHONY: start
 start:
-	docker-compose -f docker-compose.metrics.yml up -d --remove-orphans
-	DOCKER_BUILDKIT=1 COMPOSE_DOCKER_CLI_BUILD=1 docker-compose -f docker-compose.nodes.yml up --remove-orphans --build -d
+	docker-compose -f docker-compose.metrics.yml up -d
+	DOCKER_BUILDKIT=1 COMPOSE_DOCKER_CLI_BUILD=1 docker-compose -f docker-compose.nodes.yml up --build -d
 
 .PHONY: logs
 logs:

module/metrics.go

@@ -406,6 +406,6 @@ type PingMetrics interface {
 	// The nodeInfo provides additional information about the node such as the name of the node operator
 	NodeReachable(node *flow.Identity, nodeInfo string, rtt time.Duration)
 
-	// NodeInfo tracks the software version and sealed height of a node
-	NodeInfo(node *flow.Identity, nodeInfo string, version string, sealedHeight uint64)
+	// NodeInfo tracks the software version, sealed height and hotstuff view of a node
+	NodeInfo(node *flow.Identity, nodeInfo string, version string, sealedHeight uint64, hotstuffCurView uint64)
 }

module/metrics/ping.go

@@ -10,8 +10,9 @@ import (
 )
 
 type PingCollector struct {
-	reachable    *prometheus.GaugeVec
-	sealedHeight *prometheus.GaugeVec
+	reachable       *prometheus.GaugeVec
+	sealedHeight    *prometheus.GaugeVec
+	hotstuffCurView *prometheus.GaugeVec
 }
 
 func NewPingCollector() *PingCollector {
@@ -28,6 +29,12 @@ func NewPingCollector() *PingCollector {
 			Subsystem: subsystemGossip,
 			Help:      "the last sealed height of a node",
 		}, []string{LabelNodeID, LabelNodeAddress, LabelNodeRole, LabelNodeInfo, LabelNodeVersion}),
+		hotstuffCurView: promauto.NewGaugeVec(prometheus.GaugeOpts{
+			Name:      "hotstuff_curview",
+			Namespace: namespaceNetwork,
+			Subsystem: subsystemGossip,
+			Help:      "the hotstuff current view",
+		}, []string{LabelNodeID, LabelNodeAddress, LabelNodeRole, LabelNodeInfo}),
 	}
 
 	return pc
@@ -49,12 +56,19 @@ func (pc *PingCollector) NodeReachable(node *flow.Identity, nodeInfo string, rtt
 		Set(rttValue)
 }
 
-func (pc *PingCollector) NodeInfo(node *flow.Identity, nodeInfo string, version string, sealedHeight uint64) {
+func (pc *PingCollector) NodeInfo(node *flow.Identity, nodeInfo string, version string, sealedHeight uint64, hotstuffCurView uint64) {
 	pc.sealedHeight.With(prometheus.Labels{
 		LabelNodeID:      node.NodeID.String(),
 		LabelNodeAddress: node.Address,
 		LabelNodeRole:    node.Role.String(),
 		LabelNodeInfo:    nodeInfo,
 		LabelNodeVersion: version}).
 		Set(float64(sealedHeight))
+
+	pc.hotstuffCurView.With(prometheus.Labels{
+		LabelNodeID:      node.NodeID.String(),
+		LabelNodeAddress: node.Address,
+		LabelNodeInfo:    nodeInfo,
+	}).
+		Set(float64(hotstuffCurView))
 }

network/message/Makefile

@@ -1,4 +1,17 @@
-# go get github.com/gogo/protobuf/protoc-gen-gofast
+# To re-generate the the protobuf go code, install tools first:
+# ```
+# cd flow-go
+# make install-tools
+# ```
+# Install protoc:
+# https://grpc.io/docs/protoc-installation/
+#
+# Then run:
+# ```
+# cd network/message
+# make generate
+# ```
+
 
 .PHONY: generate
 generate:

network/message/ping.proto

@@ -8,4 +8,5 @@ message PingRequest {
 message PingResponse {
     string version = 1;     // node software version
     uint64 blockHeight = 2; // latest sealed block height
+    uint64 hotstuffView = 3; // latest hotstuff cur view
 }

network/p2p/dht_test.go

@@ -234,7 +234,7 @@ func (suite *DHTTestSuite) CreateNodes(count int, dhtServer bool) (nodes []*Node
 
 		connManager := NewConnManager(logger, noopMetrics)
 
-		pingInfoProvider, _, _ := MockPingInfoProvider()
+		pingInfoProvider, _, _, _ := MockPingInfoProvider()
 
 		resolver := dns.NewResolver(noopMetrics)
 

network/p2p/libp2pNode_test.go

@@ -558,16 +558,16 @@ func (suite *LibP2PNodeTestSuite) TestPing() {
 	node1Id := *identities[0]
 	node2Id := *identities[1]
 
-	_, expectedVersion, expectedHeight := MockPingInfoProvider()
+	_, expectedVersion, expectedHeight, expectedView := MockPingInfoProvider()
 
 	// test node1 can ping node 2
-	testPing(suite.T(), node1, node2Id, expectedVersion, expectedHeight)
+	testPing(suite.T(), node1, node2Id, expectedVersion, expectedHeight, expectedView)
 
 	// test node 2 can ping node 1
-	testPing(suite.T(), node2, node1Id, expectedVersion, expectedHeight)
+	testPing(suite.T(), node2, node1Id, expectedVersion, expectedHeight, expectedView)
 }
 
-func testPing(t *testing.T, source *Node, target flow.Identity, expectedVersion string, expectedHeight uint64) {
+func testPing(t *testing.T, source *Node, target flow.Identity, expectedVersion string, expectedHeight uint64, expectedView uint64) {
 	pctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	pInfo, err := PeerAddressInfo(target)
@@ -578,6 +578,7 @@ func testPing(t *testing.T, source *Node, target flow.Identity, expectedVersion
 	assert.NotZero(t, rtt)
 	assert.Equal(t, expectedVersion, resp.Version)
 	assert.Equal(t, expectedHeight, resp.BlockHeight)
+	assert.Equal(t, expectedView, resp.HotstuffView)
 }
 
 // TestConnectionGating tests node allow listing by peer.ID
@@ -699,7 +700,7 @@ func NodeFixture(t *testing.T, log zerolog.Logger, key fcrypto.PrivateKey, rootI
 		handlerFunc = func(network.Stream) {}
 	}
 
-	pingInfoProvider, _, _ := MockPingInfoProvider()
+	pingInfoProvider, _, _, _ := MockPingInfoProvider()
 
 	// dns resolver
 	resolver := dns.NewResolver(metrics.NewNoopCollector())
@@ -740,13 +741,15 @@ func NodeFixture(t *testing.T, log zerolog.Logger, key fcrypto.PrivateKey, rootI
 	return n, *identity
 }
 
-func MockPingInfoProvider() (*mocknetwork.PingInfoProvider, string, uint64) {
+func MockPingInfoProvider() (*mocknetwork.PingInfoProvider, string, uint64, uint64) {
 	version := "version_1"
 	height := uint64(5000)
+	view := uint64(10)
 	pingInfoProvider := new(mocknetwork.PingInfoProvider)
 	pingInfoProvider.On("SoftwareVersion").Return(version)
 	pingInfoProvider.On("SealedBlockHeight").Return(height)
-	return pingInfoProvider, version, height
+	pingInfoProvider.On("HotstuffView").Return(view)
+	return pingInfoProvider, version, height, view
 }
 
 // StopNodes stop all nodes in the input slice

network/p2p/ping.go

@@ -33,11 +33,13 @@ type PingService struct {
 type PingInfoProvider interface {
 	SoftwareVersion() string
 	SealedBlockHeight() uint64
+	HotstuffView() uint64
 }
 
 type PingInfoProviderImpl struct {
 	SoftwareVersionFun   func() string
 	SealedBlockHeightFun func() (uint64, error)
+	HotstuffViewFun      func() (uint64, error)
 }
 
 func (p PingInfoProviderImpl) SoftwareVersion() string {
@@ -52,6 +54,14 @@ func (p PingInfoProviderImpl) SealedBlockHeight() uint64 {
 	return height
 }
 
+func (p PingInfoProviderImpl) HotstuffView() uint64 {
+	view, err := p.HotstuffViewFun()
+	if err != nil {
+		return uint64(0)
+	}
+	return view
+}
+
 func NewPingService(h host.Host, pingProtocolID protocol.ID, pingInfoProvider PingInfoProvider, logger zerolog.Logger) *PingService {
 	ps := &PingService{host: h, pingProtocolID: pingProtocolID, pingInfoProvider: pingInfoProvider, logger: logger}
 	h.SetStreamHandler(pingProtocolID, ps.PingHandler)
@@ -115,10 +125,14 @@ func (ps *PingService) PingHandler(s network.Stream) {
 	// query for the lastest finalized block height
 	blockHeight := ps.pingInfoProvider.SealedBlockHeight()
 
+	// query for the hotstuff view
+	hotstuffView := ps.pingInfoProvider.HotstuffView()
+
 	// create a PingResponse
 	pingResponse := &message.PingResponse{
-		Version:     version,
-		BlockHeight: blockHeight,
+		Version:      version,
+		BlockHeight:  blockHeight,
+		HotstuffView: hotstuffView,
 	}
 
 	// send the PingResponse