feat(internal/database): replace chaindb/badgerdb with pebbledb

cmd/gossamer/commands/init.go

@@ -43,7 +43,12 @@ func execInit(cmd *cobra.Command) error {
 		return fmt.Errorf("failed to get --force: %s", err)
 	}
 
-	if dot.IsNodeInitialised(config.BasePath) {
+	isInitialised, err := dot.IsNodeInitialised(config.BasePath)
+	if err != nil {
+		return fmt.Errorf("checking if node is initialised: %w", err)
+	}
+
+	if isInitialised {
 		// prompt user to confirm reinitialization
 		if force || confirmMessage("Are you sure you want to reinitialise the node? [Y/n]") {
 			logger.Info("reinitialising node at base path " + config.BasePath + "...")

cmd/gossamer/commands/root.go

@@ -601,8 +601,13 @@ func execRoot(cmd *cobra.Command) error {
 		return fmt.Errorf("failed to ensure root: %s", err)
 	}
 
+	isInitialised, err := dot.IsNodeInitialised(config.BasePath)
+	if err != nil {
+		return fmt.Errorf("failed to check is not is initialised: %w", err)
+	}
+
 	// if the node is not initialised, initialise it
-	if !dot.IsNodeInitialised(config.BasePath) {
+	if !isInitialised {
 		if err := dot.InitNode(config); err != nil {
 			return fmt.Errorf("failed to initialise node: %s", err)
 		}

dot/build_spec_test.go

@@ -147,7 +147,7 @@ func TestBuildFromDB(t *testing.T) {
 				},
 			}}},
 		{name: "invalid_db_path", path: t.TempDir(),
-			err: errors.New("cannot start state service: failed to create block state: cannot get block 0: Key not found")},
+			err: errors.New("cannot start state service: failed to create block state: cannot get block 0: pebble: not found")},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

dot/network/service.go

@@ -428,6 +428,12 @@ func (s *Service) publishNetworkTelemetry(done <-chan struct{}) {
 
 func (s *Service) sentBlockIntervalTelemetry() {
 	for {
+		select {
+		case <-s.ctx.Done():
+			return
+		default:
+		}
+
 		best, err := s.blockState.BestBlockHeader()
 		if err != nil {
 			continue

dot/node.go

@@ -49,7 +49,7 @@ type Node struct {
 }
 
 type nodeBuilderIface interface {
-	isNodeInitialised(basepath string) error
+	isNodeInitialised(basepath string) (bool, error)
 	initNode(config *cfg.Config) error
 	createStateService(config *cfg.Config) (*state.Service, error)
 	createNetworkService(config *cfg.Config, stateSrvc *state.Service, telemetryMailer Telemetry) (*network.Service,
@@ -78,26 +78,37 @@ type nodeBuilder struct{}
 
 // IsNodeInitialised returns true if, within the configured data directory for the
 // node, the state database has been created and the genesis data can been loaded
-func IsNodeInitialised(basepath string) bool {
+func IsNodeInitialised(basepath string) (bool, error) {
 	nodeInstance := nodeBuilder{}
-	err := nodeInstance.isNodeInitialised(basepath)
-	return err == nil
+	return nodeInstance.isNodeInitialised(basepath)
 }
 
 // isNodeInitialised returns nil if the node is successfully initialised
 // and an error otherwise.
-func (*nodeBuilder) isNodeInitialised(basepath string) error {
+func (*nodeBuilder) isNodeInitialised(basepath string) (bool, error) {
 	// check if key registry exists
-	registry := filepath.Join(basepath, utils.DefaultDatabaseDir, "KEYREGISTRY")
+	nodeDatabaseDir := filepath.Join(basepath, utils.DefaultDatabaseDir)
 
-	_, err := os.Stat(registry)
-	if os.IsNotExist(err) {
-		return fmt.Errorf("cannot find key registry in database directory: %w", err)
+	_, err := os.Stat(nodeDatabaseDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, err
+	}
+
+	entries, err := os.ReadDir(nodeDatabaseDir)
+	if err != nil {
+		return false, fmt.Errorf("failed to read dir %s: %w", nodeDatabaseDir, err)
+	}
+
+	if len(entries) == 0 {
+		return false, nil
 	}
 
 	db, err := utils.SetupDatabase(basepath, false)
 	if err != nil {
-		return fmt.Errorf("cannot setup database: %w", err)
+		return false, fmt.Errorf("cannot setup database: %w", err)
 	}
 
 	defer func() {
@@ -109,10 +120,10 @@ func (*nodeBuilder) isNodeInitialised(basepath string) error {
 
 	_, err = state.NewBaseState(db).LoadGenesisData()
 	if err != nil {
-		return fmt.Errorf("cannot load genesis data in base state: %w", err)
+		return false, fmt.Errorf("cannot load genesis data in base state: %w", err)
 	}
 
-	return nil
+	return true, nil
 }
 
 // InitNode initialise the node with the given Config
@@ -242,7 +253,12 @@ func newNode(config *cfg.Config,
 		debug.SetGCPercent(prev)
 	}
 
-	if builder.isNodeInitialised(config.BasePath) != nil {
+	isInitialised, err := builder.isNodeInitialised(config.BasePath)
+	if err != nil {
+		return nil, fmt.Errorf("checking if node is initialised: %w", err)
+	}
+
+	if isInitialised {
 		err := builder.initNode(config)
 		if err != nil {
 			return nil, fmt.Errorf("cannot initialise node: %w", err)

dot/node_integration_test.go

@@ -89,7 +89,7 @@ func TestNewNode(t *testing.T) {
 	mockServiceRegistry.EXPECT().RegisterService(gomock.Any()).Times(8)
 
 	m := NewMocknodeBuilderIface(ctrl)
-	m.EXPECT().isNodeInitialised(initConfig.BasePath).Return(nil)
+	m.EXPECT().isNodeInitialised(initConfig.BasePath).Return(false, nil)
 	m.EXPECT().createStateService(initConfig).DoAndReturn(func(config *cfg.Config) (*state.Service, error) {
 		stateSrvc := state.NewService(stateConfig)
 		// create genesis from configuration file
@@ -218,6 +218,8 @@ func TestInitNode_Integration(t *testing.T) {
 	db, err := utils.SetupDatabase(config.BasePath, false)
 	require.NoError(t, err)
 	require.NotNil(t, db)
+	err = db.Close()
+	require.NoError(t, err)
 }
 
 func TestInitNode_GenesisSpec(t *testing.T) {
@@ -233,6 +235,9 @@ func TestInitNode_GenesisSpec(t *testing.T) {
 	db, err := utils.SetupDatabase(config.BasePath, false)
 	require.NoError(t, err)
 	require.NotNil(t, db)
+
+	err = db.Close()
+	require.NoError(t, err)
 }
 
 func TestNodeInitializedIntegration(t *testing.T) {
@@ -242,13 +247,15 @@ func TestNodeInitializedIntegration(t *testing.T) {
 
 	config.ChainSpec = genFile
 
-	result := IsNodeInitialised(config.BasePath)
+	result, err := IsNodeInitialised(config.BasePath)
+	require.NoError(t, err)
 	require.False(t, result)
 
-	err := InitNode(config)
+	err = InitNode(config)
 	require.NoError(t, err)
 
-	result = IsNodeInitialised(config.BasePath)
+	result, err = IsNodeInitialised(config.BasePath)
+	require.NoError(t, err)
 	require.True(t, result)
 }
 

dot/node_test.go

@@ -52,9 +52,13 @@ func TestInitNode(t *testing.T) {
 			err := InitNode(tt.config)
 			assert.ErrorIs(t, err, tt.err)
 			// confirm InitNode has created database dir
-			registry := filepath.Join(tt.config.BasePath, utils.DefaultDatabaseDir, "KEYREGISTRY")
-			_, err = os.Stat(registry)
+			nodeDatabaseDir := filepath.Join(tt.config.BasePath, utils.DefaultDatabaseDir)
+			_, err = os.Stat(nodeDatabaseDir)
 			require.NoError(t, err)
+
+			entries, err := os.ReadDir(nodeDatabaseDir)
+			require.NoError(t, err)
+			require.Greater(t, len(entries), 0)
 		})
 	}
 }
@@ -86,7 +90,7 @@ func TestLoadGlobalNodeName(t *testing.T) {
 		{
 			name:     "wrong basepath test",
 			basepath: t.TempDir(),
-			err:      errors.New("Key not found"),
+			err:      errors.New("pebble: not found"),
 		},
 	}
 	for _, tt := range tests {
@@ -161,7 +165,8 @@ func TestNodeInitialized(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := IsNodeInitialised(tt.basepath)
+			got, err := IsNodeInitialised(tt.basepath)
+			require.NoError(t, err)
 			assert.Equal(t, tt.want, got)
 		})
 	}

dot/rpc/modules/chain_integration_test.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/ChainSafe/gossamer/dot/state"
 	"github.com/ChainSafe/gossamer/dot/types"
+	"github.com/ChainSafe/gossamer/internal/database"
 	"github.com/ChainSafe/gossamer/internal/log"
 	"github.com/ChainSafe/gossamer/lib/common"
 	"github.com/ChainSafe/gossamer/lib/runtime"
@@ -20,7 +21,6 @@ import (
 	"github.com/ChainSafe/gossamer/pkg/scale"
 	"github.com/golang/mock/gomock"
 
-	database "github.com/ChainSafe/chaindb"
 	rtstorage "github.com/ChainSafe/gossamer/lib/runtime/storage"
 	"github.com/stretchr/testify/require"
 )
@@ -113,7 +113,7 @@ func TestChainGetHeader_NotFound(t *testing.T) {
 	req := &ChainHashRequest{Bhash: &bhash}
 
 	err = svc.GetHeader(nil, req, res)
-	require.EqualError(t, err, database.ErrKeyNotFound.Error())
+	require.EqualError(t, err, database.ErrNotFound.Error())
 }
 
 func TestChainGetBlock_Genesis(t *testing.T) {
@@ -212,7 +212,7 @@ func TestChainGetBlock_NoFound(t *testing.T) {
 	req := &ChainHashRequest{Bhash: &bhash}
 
 	err = svc.GetBlock(nil, req, res)
-	require.EqualError(t, err, database.ErrKeyNotFound.Error())
+	require.EqualError(t, err, database.ErrNotFound.Error())
 }
 
 func TestChainGetBlockHash_Latest(t *testing.T) {

dot/rpc/modules/childstate_integration_test.go

@@ -10,8 +10,8 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/ChainSafe/chaindb"
 	"github.com/ChainSafe/gossamer/dot/types"
+	"github.com/ChainSafe/gossamer/internal/database"
 	"github.com/ChainSafe/gossamer/lib/common"
 	"github.com/ChainSafe/gossamer/lib/trie"
 	"github.com/stretchr/testify/require"
@@ -97,7 +97,7 @@ func TestChildStateGetStorageSize(t *testing.T) {
 			keyChild: []byte(":not_exist"),
 		},
 		{
-			err:  chaindb.ErrKeyNotFound,
+			err:  database.ErrNotFound,
 			hash: &invalidHash,
 		},
 	}
@@ -155,7 +155,7 @@ func TestGetStorageHash(t *testing.T) {
 			keyChild: []byte(":not_exist"),
 		},
 		{
-			err:  chaindb.ErrKeyNotFound,
+			err:  database.ErrNotFound,
 			hash: &invalidBlockHash,
 		},
 	}
@@ -195,7 +195,7 @@ func TestGetChildStorage(t *testing.T) {
 		{params: []string{":child_storage_key", ""}, expected: nil},
 		{params: []string{":child_storage_key", ":child_first"}, expected: []byte(":child_first_value")},
 		{params: []string{":child_storage_key", ":child_first", blockHash.String()}, expected: []byte(":child_first_value")},
-		{params: []string{":child_storage_key", ":child_first", randomHash.String()}, errMsg: "Key not found"},
+		{params: []string{":child_storage_key", ":child_first", randomHash.String()}, errMsg: "pebble: not found"},
 	}
 
 	for _, test := range testCases {

dot/rpc/modules/state_integration_test.go

@@ -24,7 +24,7 @@ import (
 
 const (
 	RandomHash     = "0x580d77a9136035a0bc3c3cd86286172f7f81291164c5914266073a30466fba21"
-	ErrKeyNotFound = "Key not found"
+	ErrKeyNotFound = "pebble: not found"
 )
 
 func TestStateModule_GetRuntimeVersion(t *testing.T) {
@@ -118,7 +118,7 @@ func TestStateModule_GetPairs(t *testing.T) {
 			[]string{":key1", "value1"},
 			[]string{":key2", "value2"}}},
 		{params: []string{":key1", hash.String()}, expected: []interface{}{[]string{":key1", "value1"}}},
-		{params: []string{"", randomHash.String()}, errMsg: "Key not found"},
+		{params: []string{"", randomHash.String()}, errMsg: "pebble: not found"},
 	}
 
 	for _, test := range testCases {
@@ -182,7 +182,7 @@ func TestStateModule_GetStorage(t *testing.T) {
 		{params: []string{""}, expected: nil},
 		{params: []string{":key1"}, expected: []byte("value1")},
 		{params: []string{":key1", hash.String()}, expected: []byte("value1")},
-		{params: []string{"", randomHash.String()}, errMsg: "Key not found"},
+		{params: []string{"", randomHash.String()}, errMsg: "pebble: not found"},
 	}
 
 	for _, test := range testCases {
@@ -235,7 +235,7 @@ func TestStateModule_GetStorageHash(t *testing.T) {
 		{params: []string{""}, expected: hashOfNil},
 		{params: []string{":key1"}, expected: hash1},
 		{params: []string{":key1", hash.String()}, expected: hash1},
-		{params: []string{"0x", randomHash.String()}, errMsg: "Key not found"},
+		{params: []string{"0x", randomHash.String()}, errMsg: "pebble: not found"},
 	}
 
 	for _, test := range testCases {
@@ -280,7 +280,7 @@ func TestStateModule_GetStorageSize(t *testing.T) {
 		{params: []string{""}},
 		{params: []string{":key1"}, expected: 6},
 		{params: []string{":key1", hash.String()}, expected: 6},
-		{params: []string{"0x", randomHash.String()}, errMsg: "Key not found"},
+		{params: []string{"0x", randomHash.String()}, errMsg: "pebble: not found"},
 	}
 
 	for _, test := range testCases {

dot/services.go

@@ -10,7 +10,6 @@ import (
 
 	cfg "github.com/ChainSafe/gossamer/config"
 
-	"github.com/ChainSafe/chaindb"
 	"github.com/ChainSafe/gossamer/dot/core"
 	"github.com/ChainSafe/gossamer/dot/digest"
 	"github.com/ChainSafe/gossamer/dot/network"
@@ -20,6 +19,7 @@ import (
 	"github.com/ChainSafe/gossamer/dot/sync"
 	"github.com/ChainSafe/gossamer/dot/system"
 	"github.com/ChainSafe/gossamer/dot/types"
+	"github.com/ChainSafe/gossamer/internal/database"
 	"github.com/ChainSafe/gossamer/internal/log"
 	"github.com/ChainSafe/gossamer/internal/metrics"
 	"github.com/ChainSafe/gossamer/internal/pprof"
@@ -56,7 +56,7 @@ type rpcServiceSettings struct {
 	syncer        *sync.Service
 }
 
-func newInMemoryDB() (*chaindb.BadgerDB, error) {
+func newInMemoryDB() (database.Database, error) {
 	return utils.SetupDatabase("", true)
 }
 
@@ -110,7 +110,7 @@ func (nodeBuilder) createRuntimeStorage(st *state.Service) (*runtime.NodeStorage
 
 	return &runtime.NodeStorage{
 		LocalStorage:      localStorage,
-		PersistentStorage: chaindb.NewTable(st.DB(), "offlinestorage"),
+		PersistentStorage: database.NewTable(st.DB(), "offlinestorage"),
 		BaseDB:            st.Base,
 	}, nil
 }