feat(types): Deprecate the DBBackend variable in favor of new app-db-backend config entry

CHANGELOG.md

@@ -164,6 +164,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 * (types/errors) [\#10779](https://github.com/cosmos/cosmos-sdk/pull/10779) Move most functionality in `types/errors` to a standalone `errors` go module, except the `RootCodespace` errors and ABCI response helpers. All functions and types that used to live in `types/errors` are now aliased so this is not a breaking change.
 * (gov) [\#10854](https://github.com/cosmos/cosmos-sdk/pull/10854) v1beta2's vote doesn't include the deprecate `option VoteOption` anymore. Instead, it only uses `WeightedVoteOption`.
 * (types) [\#11004](https://github.com/cosmos/cosmos-sdk/pull/11004) Added mutable versions of many of the sdk.Dec types operations.  This improves performance when used by avoiding reallocating a new bigint for each operation.
+* (types) [\#10948](https://github.com/cosmos/cosmos-sdk/issues/10948) Use Tendermint `db-backend` config value instead of compile-time `types.DBBackend` value.
 
 ### Bug Fixes
 
@@ -217,6 +218,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 ### Deprecated
 
 * (x/upgrade) [\#9906](https://github.com/cosmos/cosmos-sdk/pull/9906) Deprecate `UpgradeConsensusState` gRPC query since this functionality is only used for IBC, which now has its own [IBC replacement](https://github.com/cosmos/ibc-go/blob/2c880a22e9f9cc75f62b527ca94aa75ce1106001/proto/ibc/core/client/v1/query.proto#L54)
+* (types) [\#10948](https://github.com/cosmos/cosmos-sdk/issues/10948) Deprecate the types.DBBackend variable and types.NewLevelDB function in favor of the new types.NewDB function that takes in a db backend type.
 
 ## [v0.45.0](https://github.com/cosmos/cosmos-sdk/releases/tag/v0.45.0) - 2022-01-18
 

server/constructors_test.go

@@ -9,7 +9,7 @@ import (
 
 func Test_openDB(t *testing.T) {
 	t.Parallel()
-	_, err := openDB(t.TempDir())
+	_, err := openDB(t.TempDir(), "")
 	require.NoError(t, err)
 }
 

server/export.go

@@ -37,7 +37,7 @@ func ExportCmd(appExporter types.AppExporter, defaultNodeHome string) *cobra.Com
 				return err
 			}
 
-			db, err := openDB(config.RootDir)
+			db, err := openDB(config.RootDir, config.DBBackend)
 			if err != nil {
 				return err
 			}

server/mock/app.go

@@ -34,7 +34,7 @@ func testTxHandler(options middleware.TxHandlerOptions) tx.Handler {
 // similar to a real app. Make sure rootDir is empty before running the test,
 // in order to guarantee consistent results
 func NewApp(rootDir string, logger log.Logger) (abci.Application, error) {
-	db, err := sdk.NewLevelDB("mock", filepath.Join(rootDir, "data"))
+	db, err := sdk.NewDB("mock", "", filepath.Join(rootDir, "data"))
 	if err != nil {
 		return nil, err
 	}

server/start.go

@@ -169,7 +169,7 @@ func startStandAlone(ctx *Context, appCreator types.AppCreator) error {
 	transport := ctx.Viper.GetString(flagTransport)
 	home := ctx.Viper.GetString(flags.FlagHome)
 
-	db, err := openDB(home)
+	db, err := openDB(home, ctx.Viper.GetString("db-backend"))
 	if err != nil {
 		return err
 	}
@@ -229,7 +229,7 @@ func startInProcess(ctx *Context, clientCtx client.Context, appCreator types.App
 	}
 
 	traceWriterFile := ctx.Viper.GetString(flagTraceStore)
-	db, err := openDB(home)
+	db, err := openDB(home, cfg.DBBackend)
 	if err != nil {
 		return err
 	}

server/util.go

@@ -371,9 +371,9 @@ func addrToIP(addr net.Addr) net.IP {
 	return ip
 }
 
-func openDB(rootDir string) (dbm.DB, error) {
+func openDB(rootDir, backendType string) (dbm.DB, error) {
 	dataDir := filepath.Join(rootDir, "data")
-	return sdk.NewLevelDB("application", dataDir)
+	return sdk.NewDB("application", backendType, dataDir)
 }
 
 func openTraceWriter(traceWriterFile string) (w io.Writer, err error) {

simapp/config.go

@@ -22,6 +22,7 @@ var (
 	FlagCommitValue             bool
 	FlagOnOperationValue        bool // TODO: Remove in favor of binary search for invariant violation
 	FlagAllInvariantsValue      bool
+	FlagDBBackendValue          string
 
 	FlagEnabledValue     bool
 	FlagVerboseValue     bool
@@ -46,6 +47,7 @@ func GetSimulatorFlags() {
 	flag.BoolVar(&FlagCommitValue, "Commit", false, "have the simulation commit")
 	flag.BoolVar(&FlagOnOperationValue, "SimulateEveryOperation", false, "run slow invariants every operation")
 	flag.BoolVar(&FlagAllInvariantsValue, "PrintAllInvariants", false, "print all invariants if a broken invariant is found")
+	flag.StringVar(&FlagDBBackendValue, "DBBackend", "goleveldb", "custom db backend type")
 
 	// simulation flags
 	flag.BoolVar(&FlagEnabledValue, "Enabled", false, "enable the simulation")
@@ -71,5 +73,6 @@ func NewConfigFromFlags() simulation.Config {
 		Commit:             FlagCommitValue,
 		OnOperation:        FlagOnOperationValue,
 		AllInvariants:      FlagAllInvariantsValue,
+		DBBackend:          FlagDBBackendValue,
 	}
 }

simapp/simd/cmd/root.go

@@ -261,7 +261,7 @@ func (a appCreator) newApp(logger log.Logger, db dbm.DB, traceStore io.Writer, a
 	}
 
 	snapshotDir := filepath.Join(cast.ToString(appOpts.Get(flags.FlagHome)), "data", "snapshots")
-	snapshotDB, err := sdk.NewLevelDB("metadata", snapshotDir)
+	snapshotDB, err := sdk.NewDB("metadata", cast.ToString(appOpts.Get("db-backend")), snapshotDir)
 	if err != nil {
 		panic(err)
 	}

simapp/utils.go

@@ -39,7 +39,7 @@ func SetupSimulation(dirPrefix, dbName string) (simtypes.Config, dbm.DB, string,
 		return simtypes.Config{}, nil, "", nil, false, err
 	}
 
-	db, err := sdk.NewLevelDB(dbName, dir)
+	db, err := sdk.NewDB(dbName, config.DBBackend, dir)
 	if err != nil {
 		return simtypes.Config{}, nil, "", nil, false, err
 	}

types/simulation/config.go

@@ -21,4 +21,6 @@ type Config struct {
 
 	OnOperation   bool // run slow invariants every operation
 	AllInvariants bool // print all failed invariants if a broken invariant is found
+
+	DBBackend string // custom db backend type
 }

types/utils.go

@@ -11,13 +11,15 @@ import (
 
 var (
 	// This is set at compile time. Could be cleveldb, defaults is goleveldb.
-	DBBackend = ""
+	DBBackend = "" // Deprecated: Use tendermint config's DBBackend value instead.
 	backend   = dbm.GoLevelDBBackend
 )
 
 func init() {
 	if len(DBBackend) != 0 {
 		backend = dbm.BackendType(DBBackend)
+	} else {
+		DBBackend = string(backend)
 	}
 }
 
@@ -85,6 +87,8 @@ func ParseTimeBytes(bz []byte) (time.Time, error) {
 }
 
 // NewLevelDB instantiate a new LevelDB instance according to DBBackend.
+//
+// Deprecated: Use NewDB instead. Suggested backendType is tendermint config's DBBackend value.
 func NewLevelDB(name, dir string) (db dbm.DB, err error) {
 	defer func() {
 		if r := recover(); r != nil {
@@ -95,6 +99,27 @@ func NewLevelDB(name, dir string) (db dbm.DB, err error) {
 	return dbm.NewDB(name, backend, dir)
 }
 
+// NewDB instantiate a new DB instance.
+// This differs from the tendermint/tm-db.NewDB function in three ways:
+// 1) Returns an error instead of panicking.
+// 2) Takes in a string for the backend type.
+// 3) If the backendType is an empty string, "goleveldb" is used.
+func NewDB(name, backendType, dir string) (db dbm.DB, err error) {
+	defer func() {
+		r := recover()
+		switch {
+		case r != nil:
+			err = fmt.Errorf("could not create %q db in %s with name %q: %v", backendType, dir, name, r)
+		case err != nil:
+			err = fmt.Errorf("could not create %q db in %s with name %q: %w", backendType, dir, name, err)
+		}
+	}()
+	if len(backendType) == 0 {
+		backendType = string(dbm.GoLevelDBBackend)
+	}
+	return dbm.NewDB(name, dbm.BackendType(backendType), dir)
+}
+
 // copy bytes
 func CopyBytes(bz []byte) (ret []byte) {
 	if bz == nil {

types/utils_test.go

@@ -5,9 +5,13 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	dbm "github.com/tendermint/tm-db"
 )
 
 type utilsTestSuite struct {
@@ -109,3 +113,66 @@ func (s *utilsTestSuite) TestParseTimeBytes() {
 	_, err = sdk.ParseTimeBytes([]byte{})
 	s.Require().Error(err)
 }
+
+func (s *utilsTestSuite) TestNewDB() {
+	tests := []struct {
+		testName string
+
+		name        string
+		backendType string
+
+		isGoLevelDB bool
+		isMemDB     bool
+		errContains []string
+	}{
+		{
+			testName:    "unknown backendType gives error",
+			name:        "test-unknown",
+			backendType: "baddbtype",
+			errContains: []string{"could not create", "test-unknown", "unknown", "baddbtype", "goleveldb"},
+		},
+		{
+			testName:    "empty backendType defaults to goleveldb",
+			name:        "test-empty",
+			backendType: "",
+			isGoLevelDB: true,
+		},
+		{
+			testName:    "goleveldb returns a GoLevelDB",
+			name:        "test-goleveldb",
+			backendType: "goleveldb",
+			isGoLevelDB: true,
+		},
+		{
+			testName:    "memdb returns a MemDB",
+			name:        "test-memdb",
+			backendType: "memdb",
+			isMemDB:     true,
+		},
+	}
+
+	for _, tc := range tests {
+		s.T().Run(tc.testName, func(t *testing.T) {
+			dir := t.TempDir()
+			var db dbm.DB
+			var err error
+			require.NotPanics(t, func() {
+				db, err = sdk.NewDB(tc.name, tc.backendType, dir)
+			}, "calling NewDB")
+			if len(tc.errContains) != 0 {
+				require.Error(t, err, "err")
+				for _, exp := range tc.errContains {
+					assert.Contains(t, err.Error(), exp, "err.Error()")
+				}
+			} else {
+				require.NoError(t, err, "err")
+				require.NotNil(t, db, "db")
+				assert.NoError(t, db.Close(), "db.Close()")
+				_, isGoLevelDB := db.(*dbm.GoLevelDB)
+				assert.Equal(t, tc.isGoLevelDB, isGoLevelDB, "isGoLevelDB")
+				_, isMemDB := db.(*dbm.MemDB)
+				assert.Equal(t, tc.isMemDB, isMemDB, "isMemDB")
+			}
+		})
+	}
+}