Merge pull request #6177 from oasisprotocol/peternose/trivial/refactor-consensus-backend

go/consensus/api: Refactor consensus interfaces

Author: peternose

.changelog/6177.trivial.md

@@ -12,7 +12,7 @@ import (
 	"github.com/oasisprotocol/oasis-core/go/beacon/api"
 	memorySigner "github.com/oasisprotocol/oasis-core/go/common/crypto/signature/signers/memory"
 	"github.com/oasisprotocol/oasis-core/go/common/node"
-	consensus "github.com/oasisprotocol/oasis-core/go/consensus/api"
+	consensusAPI "github.com/oasisprotocol/oasis-core/go/consensus/api"
 	"github.com/oasisprotocol/oasis-core/go/consensus/api/transaction"
 )
 
@@ -23,28 +23,28 @@ var TestSigner = memorySigner.NewTestSigner("oasis-core epochtime mock key seed"
 
 // BeaconImplementationTests exercises the basic functionality of a
 // beacon backend.
-func BeaconImplementationTests(t *testing.T, backend consensus.Backend) {
+func BeaconImplementationTests(t *testing.T, consensus consensusAPI.Service) {
 	require := require.New(t)
 
-	timeSource := backend.Beacon()
+	timeSource := consensus.Beacon()
 
-	beacon, err := timeSource.GetBeacon(context.Background(), consensus.HeightLatest)
+	beacon, err := timeSource.GetBeacon(context.Background(), consensusAPI.HeightLatest)
 	require.NoError(err, "GetBeacon")
 	require.Len(beacon, api.BeaconSize, "GetBeacon - length")
 
-	_ = MustAdvanceEpoch(t, backend)
+	_ = MustAdvanceEpoch(t, consensus)
 
-	newBeacon, err := timeSource.GetBeacon(context.Background(), consensus.HeightLatest)
+	newBeacon, err := timeSource.GetBeacon(context.Background(), consensusAPI.HeightLatest)
 	require.NoError(err, "GetBeacon")
 	require.Len(newBeacon, api.BeaconSize, "GetBeacon - length")
 	require.NotEqual(beacon, newBeacon, "After epoch transition, new beacon should be generated.")
 
-	latestEpoch, err := timeSource.GetEpoch(context.Background(), consensus.HeightLatest)
+	latestEpoch, err := timeSource.GetEpoch(context.Background(), consensusAPI.HeightLatest)
 	require.NoError(err, "GetEpoch")
 
 	// Querying epoch for a non-existing height should fail.
 	_, err = timeSource.GetEpoch(context.Background(), 100000000000)
-	require.ErrorIs(err, consensus.ErrVersionNotFound, "GetEpoch should fail for non-existing height")
+	require.ErrorIs(err, consensusAPI.ErrVersionNotFound, "GetEpoch should fail for non-existing height")
 
 	var lastHeight int64
 	for epoch := api.EpochTime(0); epoch <= latestEpoch; epoch++ {
@@ -57,16 +57,16 @@ func BeaconImplementationTests(t *testing.T, backend consensus.Backend) {
 
 // EpochtimeSetableImplementationTest exercises the basic functionality of
 // a setable (mock) epochtime backend.
-func EpochtimeSetableImplementationTest(t *testing.T, backend consensus.Backend) {
+func EpochtimeSetableImplementationTest(t *testing.T, consensus consensusAPI.Service) {
 	require := require.New(t)
 
-	timeSource := backend.Beacon()
+	timeSource := consensus.Beacon()
 
-	parameters, err := timeSource.ConsensusParameters(context.Background(), consensus.HeightLatest)
+	parameters, err := timeSource.ConsensusParameters(context.Background(), consensusAPI.HeightLatest)
 	require.NoError(err, "ConsensusParameters")
 	require.True(parameters.DebugMockBackend, "expected debug backend")
 
-	epoch, err := timeSource.GetEpoch(context.Background(), consensus.HeightLatest)
+	epoch, err := timeSource.GetEpoch(context.Background(), consensusAPI.HeightLatest)
 	require.NoError(err, "GetEpoch")
 
 	var e api.EpochTime
@@ -92,7 +92,7 @@ func EpochtimeSetableImplementationTest(t *testing.T, backend consensus.Backend)
 	}
 
 	epoch++
-	err = SetEpoch(context.Background(), epoch, backend)
+	err = SetEpoch(context.Background(), epoch, consensus)
 	require.NoError(err, "SetEpoch")
 
 	select {
@@ -109,28 +109,28 @@ func EpochtimeSetableImplementationTest(t *testing.T, backend consensus.Backend)
 		t.Fatalf("failed to receive latest epoch after transition")
 	}
 
-	e, err = timeSource.GetEpoch(context.Background(), consensus.HeightLatest)
+	e, err = timeSource.GetEpoch(context.Background(), consensusAPI.HeightLatest)
 	require.NoError(err, "GetEpoch after set")
 	require.Equal(epoch, e, "GetEpoch after set, epoch")
 }
 
 // MustAdvanceEpoch advances the epoch and returns the new epoch.
-func MustAdvanceEpoch(t *testing.T, backend consensus.Backend) api.EpochTime {
+func MustAdvanceEpoch(t *testing.T, consensus consensusAPI.Service) api.EpochTime {
 	require := require.New(t)
 
-	timeSource := backend.Beacon()
+	timeSource := consensus.Beacon()
 
 	ctx, cancel := context.WithTimeout(context.Background(), recvTimeout)
 	defer cancel()
 
-	epoch, err := timeSource.GetEpoch(ctx, consensus.HeightLatest)
+	epoch, err := timeSource.GetEpoch(ctx, consensusAPI.HeightLatest)
 	require.NoError(err, "GetEpoch")
 
 	// While using a timeout here would be nice, the correct timeout value
 	// depends on the block interval and all the various internal timekeeping
 	// periods so it's not easy to set one.
 	epoch++
-	err = SetEpoch(context.Background(), epoch, backend)
+	err = SetEpoch(context.Background(), epoch, consensus)
 	require.NoError(err, "SetEpoch")
 
 	return epoch
@@ -141,16 +141,16 @@ func MustAdvanceEpoch(t *testing.T, backend consensus.Backend) api.EpochTime {
 // Between each epoch increment the method ensures that the consensus validator is re-registered
 // so that epochs are not advanced too fast, which could cause a consensus error due to no
 // validators being registered for the epoch.
-func MustAdvanceEpochMulti(t *testing.T, backend consensus.Backend, increment uint64) api.EpochTime {
+func MustAdvanceEpochMulti(t *testing.T, consensus consensusAPI.Service, increment uint64) api.EpochTime {
 	require := require.New(t)
 
-	timeSource := backend.Beacon()
-	registry := backend.Registry()
+	timeSource := consensus.Beacon()
+	registry := consensus.Registry()
 
 	ctx, cancel := context.WithTimeout(context.Background(), recvTimeout)
 	defer cancel()
 
-	epoch, err := timeSource.GetEpoch(ctx, consensus.HeightLatest)
+	epoch, err := timeSource.GetEpoch(ctx, consensusAPI.HeightLatest)
 	require.NoError(err, "GetEpoch")
 
 	// While using a timeout here would be nice, the correct timeout value
@@ -167,7 +167,7 @@ func MustAdvanceEpochMulti(t *testing.T, backend consensus.Backend, increment ui
 		// While using a timeout here would be nice, the correct timeout value
 		// depends on the block interval and all the various internal timekeeping
 		// periods so it's not easy to set one.
-		err = SetEpoch(context.Background(), epoch, backend)
+		err = SetEpoch(context.Background(), epoch, consensus)
 		require.NoError(err, "SetEpoch")
 
 		// Ensure validator re-registers before transitioning to next epoch.
@@ -194,15 +194,15 @@ func MustAdvanceEpochMulti(t *testing.T, backend consensus.Backend, increment ui
 }
 
 // SetEpoch sets the current epoch.
-func SetEpoch(ctx context.Context, epoch api.EpochTime, backend consensus.Backend) error {
-	ch, sub, err := backend.Beacon().WatchEpochs(ctx)
+func SetEpoch(ctx context.Context, epoch api.EpochTime, consensus consensusAPI.Service) error {
+	ch, sub, err := consensus.Beacon().WatchEpochs(ctx)
 	if err != nil {
 		return fmt.Errorf("watch epochs failed: %w", err)
 	}
 	defer sub.Close()
 
 	tx := transaction.NewTransaction(0, nil, api.MethodSetEpoch, epoch)
-	if err := consensus.SignAndSubmitTx(ctx, backend, TestSigner, tx); err != nil {
+	if err := consensusAPI.SignAndSubmitTx(ctx, consensus, TestSigner, tx); err != nil {
 		return fmt.Errorf("set epoch failed: %w", err)
 	}
 

go/beacon/tests/tester.go

@@ -109,8 +109,8 @@ func (m FeatureMask) Has(f FeatureMask) bool {
 	return m&f != 0
 }
 
-// ClientBackend is a consensus interface used by clients that connect to the local full node.
-type ClientBackend interface {
+// Backend is a consensus interface used by clients that connect to the local full node.
+type Backend interface {
 	// SubmitTx submits a signed consensus transaction and waits for the transaction to be included
 	// in a block. Use SubmitTxNoWait if you only need to broadcast the transaction.
 	SubmitTx(ctx context.Context, tx *transaction.SignedTransaction) error
@@ -193,30 +193,36 @@ type ClientBackend interface {
 
 	// GetNextBlockState returns the state of the next block being voted on by validators.
 	GetNextBlockState(ctx context.Context) (*NextBlockState, error)
+}
 
+// Services are consensus services.
+type Services interface {
 	// Beacon returns the beacon backend.
 	Beacon() beacon.Backend
 
+	// Core returns the consensus core backend.
+	Core() Backend
+
+	// Governance returns the governance backend.
+	Governance() governance.Backend
+
+	// KeyManager returns the keymanager backend.
+	KeyManager() keymanager.Backend
+
 	// Registry returns the registry backend.
 	Registry() registry.Backend
 
-	// Staking returns the staking backend.
-	Staking() staking.Backend
+	// RootHash returns the roothash backend.
+	RootHash() roothash.Backend
 
 	// Scheduler returns the scheduler backend.
 	Scheduler() scheduler.Backend
 
-	// Governance returns the governance backend.
-	Governance() governance.Backend
-
-	// RootHash returns the roothash backend.
-	RootHash() roothash.Backend
+	// Staking returns the staking backend.
+	Staking() staking.Backend
 
 	// Vault returns the vault backend.
 	Vault() vault.Backend
-
-	// KeyManager returns the keymanager backend.
-	KeyManager() keymanager.Backend
 }
 
 // Block is a consensus block.
@@ -371,10 +377,10 @@ type P2PStatus struct {
 	Peers []string `json:"peers"`
 }
 
-// Backend is an interface that a consensus backend must provide.
-type Backend interface {
+// Service is an interface that a consensus backend service must provide.
+type Service interface {
 	service.BackgroundService
-	ClientBackend
+	Services
 
 	// SupportedFeatures returns the features supported by this consensus backend.
 	SupportedFeatures() FeatureMask