Move data-format-exception at a common place

This CR moves data format exception at a common place so that it can be
used both in leveldb and couchdb

FAB-15491 #done

Change-Id: I355cbc7d851511c39a100b7f098f884623431104
Signed-off-by: manish <[email protected]>

common/ledger/dataformat/dataformats.go

@@ -0,0 +1,37 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package dataformat
+
+import "fmt"
+
+const (
+	// Version1x specifies the data format in version 1.x
+	Version1x = ""
+
+	// Version20 specifies the data format in version 2.0
+	Version20 = "2.0"
+)
+
+// ErrVersionMismatch is returned if it is detected that the version of the format recorded in
+// the internal database is different from what is specified in the `Conf` that is used for opening the db
+type ErrVersionMismatch struct {
+	DBInfo          string
+	ExpectedVersion string
+	Version         string
+}
+
+func (e *ErrVersionMismatch) Error() string {
+	return fmt.Sprintf("unexpected format. db info = [%s], data format = [%s], expected format = [%s]",
+		e.DBInfo, e.Version, e.ExpectedVersion,
+	)
+}
+
+// IsVersionMismatch returns true if err is an ErrVersionMismatch
+func IsVersionMismatch(err error) bool {
+	_, ok := err.(*ErrVersionMismatch)
+	return ok
+}

common/ledger/util/leveldbhelper/leveldb_provider.go

@@ -11,6 +11,7 @@ import (
 	"fmt"
 	"sync"
 
+	"github.com/hyperledger/fabric/common/ledger/dataformat"
 	"github.com/syndtr/goleveldb/leveldb"
 	"github.com/syndtr/goleveldb/leveldb/iterator"
 )
@@ -37,26 +38,6 @@ type Conf struct {
 	ExpectedFormatVersion string
 }
 
-// ErrFormatVersionMismatch is returned if it is detected that the version of the format recorded in
-// the internal database is different from what is specified in the `Conf` that is used for opening the db
-type ErrFormatVersionMismatch struct {
-	DBPath                string
-	ExpectedFormatVersion string
-	DataFormatVersion     string
-}
-
-func (e *ErrFormatVersionMismatch) Error() string {
-	return fmt.Sprintf("unexpected format. db path = [%s], data format = [%s], expected format = [%s]",
-		e.DBPath, e.DataFormatVersion, e.ExpectedFormatVersion,
-	)
-}
-
-// IsFormatVersionMismatch returns true if err is an errFormatMismatch
-func IsFormatVersionMismatch(err error) bool {
-	_, ok := err.(*ErrFormatVersionMismatch)
-	return ok
-}
-
 // Provider enables to use a single leveldb as multiple logical leveldbs
 type Provider struct {
 	db *DB
@@ -114,9 +95,12 @@ func openDBAndCheckFormat(conf *Conf) (d *DB, e error) {
 	if !bytes.Equal(formatVersion, []byte(conf.ExpectedFormatVersion)) {
 		logger.Errorf("The db at path [%s] contains data in unexpected format. expected data format = [%s] (%#v), data format = [%s] (%#v).",
 			conf.DBPath, conf.ExpectedFormatVersion, []byte(conf.ExpectedFormatVersion), formatVersion, formatVersion)
-		return nil, &ErrFormatVersionMismatch{ExpectedFormatVersion: conf.ExpectedFormatVersion, DataFormatVersion: string(formatVersion), DBPath: conf.DBPath}
+		return nil, &dataformat.ErrVersionMismatch{
+			ExpectedVersion: conf.ExpectedFormatVersion,
+			Version:         string(formatVersion),
+			DBInfo:          fmt.Sprintf("leveldb at [%s]", conf.DBPath),
+		}
 	}
-
 	logger.Debug("format is latest, nothing to do")
 	return db, nil
 }

common/ledger/util/leveldbhelper/leveldb_provider_test.go

@@ -11,6 +11,8 @@ import (
 	"os"
 	"testing"
 
+	"github.com/hyperledger/fabric/common/ledger/dataformat"
+
 	"github.com/hyperledger/fabric/common/flogging"
 	"github.com/stretchr/testify/assert"
 )
@@ -92,7 +94,7 @@ func TestFormatCheck(t *testing.T) {
 		dataFormat     string
 		dataExists     bool
 		expectedFormat string
-		expectedErr    *ErrFormatVersionMismatch
+		expectedErr    *dataformat.ErrVersionMismatch
 	}{
 		{
 			dataFormat:     "",
@@ -116,7 +118,7 @@ func TestFormatCheck(t *testing.T) {
 			dataFormat:     "",
 			dataExists:     true,
 			expectedFormat: "2.0",
-			expectedErr:    &ErrFormatVersionMismatch{DataFormatVersion: "", ExpectedFormatVersion: "2.0"},
+			expectedErr:    &dataformat.ErrVersionMismatch{Version: "", ExpectedVersion: "2.0"},
 		},
 		{
 			dataFormat:     "2.0",
@@ -128,7 +130,7 @@ func TestFormatCheck(t *testing.T) {
 			dataFormat:     "2.0",
 			dataExists:     true,
 			expectedFormat: "3.0",
-			expectedErr:    &ErrFormatVersionMismatch{DataFormatVersion: "2.0", ExpectedFormatVersion: "3.0"},
+			expectedErr:    &dataformat.ErrVersionMismatch{Version: "2.0", ExpectedVersion: "3.0"},
 		},
 	}
 
@@ -141,7 +143,7 @@ func TestFormatCheck(t *testing.T) {
 	}
 }
 
-func testFormatCheck(t *testing.T, dataFormat, expectedFormat string, dataExists bool, expectedErr *ErrFormatVersionMismatch) {
+func testFormatCheck(t *testing.T, dataFormat, expectedFormat string, dataExists bool, expectedErr *dataformat.ErrVersionMismatch) {
 	assert.NoError(t, os.RemoveAll(testDBPath))
 	defer func() {
 		assert.NoError(t, os.RemoveAll(testDBPath))
@@ -161,7 +163,7 @@ func testFormatCheck(t *testing.T, dataFormat, expectedFormat string, dataExists
 	p.Close()
 	p, err = NewProvider(&Conf{DBPath: testDBPath, ExpectedFormatVersion: expectedFormat})
 	if expectedErr != nil {
-		expectedErr.DBPath = testDBPath
+		expectedErr.DBInfo = fmt.Sprintf("leveldb at [%s]", testDBPath)
 		assert.Equal(t, err, expectedErr)
 		return
 	}

core/ledger/kvledger/kv_ledger_provider.go

@@ -78,8 +78,8 @@ func NewProvider(initializer *ledger.Initializer) (pr *Provider, e error) {
 	defer func() {
 		if e != nil {
 			p.Close()
-			if errFormatMismatch, ok := e.(*leveldbhelper.ErrFormatVersionMismatch); ok {
-				if errFormatMismatch.DataFormatVersion == dataformat.Version1x && errFormatMismatch.ExpectedFormatVersion == dataformat.Version20 {
+			if errFormatMismatch, ok := e.(*dataformat.ErrVersionMismatch); ok {
+				if errFormatMismatch.Version == dataformat.Version1x && errFormatMismatch.ExpectedVersion == dataformat.Version20 {
 					logger.Errorf("Please execute the 'peer node upgrade-dbs' command to upgrade the database format: %s", errFormatMismatch)
 				} else {
 					logger.Errorf("Please check the Fabric version matches the ledger data format: %s", errFormatMismatch)
@@ -402,7 +402,11 @@ func openIDStore(path string) (s *idStore, e error) {
 	if !bytes.Equal(formatVersion, expectedFormatBytes) {
 		logger.Errorf("The db at path [%s] contains data in unexpected format. expected data format = [%s] (%#v), data format = [%s] (%#v).",
 			path, dataformat.Version20, expectedFormatBytes, formatVersion, formatVersion)
-		return nil, &leveldbhelper.ErrFormatVersionMismatch{ExpectedFormatVersion: dataformat.Version20, DataFormatVersion: string(formatVersion), DBPath: path}
+		return nil, &dataformat.ErrVersionMismatch{
+			ExpectedVersion: dataformat.Version20,
+			Version:         string(formatVersion),
+			DBInfo:          fmt.Sprintf("leveldb for channel-IDs at [%s]", path),
+		}
 	}
 	return &idStore{db, path}, nil
 }
@@ -418,7 +422,11 @@ func (s *idStore) upgradeFormat() error {
 		return nil
 	}
 	if format != nil {
-		err = &leveldbhelper.ErrFormatVersionMismatch{ExpectedFormatVersion: "", DataFormatVersion: string(format), DBPath: s.dbPath}
+		err = &dataformat.ErrVersionMismatch{
+			ExpectedVersion: "",
+			Version:         string(format),
+			DBInfo:          fmt.Sprintf("leveldb for channel-IDs at [%s]", s.dbPath),
+		}
 		logger.Errorf("Failed to upgrade format [%#v] to new format [%#v]: %s", format, idStoreFormatBytes, err)
 		return err
 	}

core/ledger/kvledger/kv_ledger_provider_test.go

@@ -152,7 +152,7 @@ func TestNewProviderIdStoreFormatError(t *testing.T) {
 			Config:                        conf,
 		},
 	)
-	require.EqualError(t, err, fmt.Sprintf("unexpected format. db path = [%s], data format = [], expected format = [2.0]", LedgerProviderPath(conf.RootFSPath)))
+	require.EqualError(t, err, fmt.Sprintf("unexpected format. db info = [leveldb for channel-IDs at [%s]], data format = [], expected format = [2.0]", LedgerProviderPath(conf.RootFSPath)))
 }
 
 func TestUpgradeIDStoreFormatDBError(t *testing.T) {

core/ledger/kvledger/tests/v11_test.go

@@ -32,7 +32,7 @@ func TestV11(t *testing.T) {
 	idStorePath := kvledger.LedgerProviderPath(ledgerFSRoot)
 	assert.PanicsWithValue(
 		t,
-		fmt.Sprintf("Error in instantiating ledger provider: unexpected format. db path = [%s], data format = [], expected format = [2.0]",
+		fmt.Sprintf("Error in instantiating ledger provider: unexpected format. db info = [leveldb for channel-IDs at [%s]], data format = [], expected format = [2.0]",
 			idStorePath),
 		func() { env.initLedgerMgmt() },
 		"A panic should occur because idstore is in format 1.x",
@@ -43,7 +43,7 @@ func TestV11(t *testing.T) {
 	blkIndexPath := path.Join(kvledger.BlockStorePath(ledgerFSRoot), "index")
 	require.PanicsWithValue(
 		t,
-		fmt.Sprintf("Error in instantiating ledger provider: unexpected format. db path = [%s], data format = [], expected format = [2.0]",
+		fmt.Sprintf("Error in instantiating ledger provider: unexpected format. db info = [leveldb at [%s]], data format = [], expected format = [2.0]",
 			blkIndexPath),
 		func() { env.initLedgerMgmt() },
 		"A panic should occur because block store index is in format 1.x",
@@ -54,7 +54,7 @@ func TestV11(t *testing.T) {
 	historyDBPath := kvledger.HistoryDBPath(ledgerFSRoot)
 	require.PanicsWithValue(
 		t,
-		fmt.Sprintf("Error in instantiating ledger provider: unexpected format. db path = [%s], data format = [], expected format = [2.0]",
+		fmt.Sprintf("Error in instantiating ledger provider: unexpected format. db info = [leveldb at [%s]], data format = [], expected format = [2.0]",
 			historyDBPath),
 		func() { env.initLedgerMgmt() },
 		"A panic should occur because history is in format 1.x",
@@ -66,7 +66,7 @@ func TestV11(t *testing.T) {
 	require.PanicsWithValue(
 		t,
 		fmt.Sprintf(
-			"Error in instantiating ledger provider: unexpected format. db path = [%s], data format = [], expected format = [2.0]",
+			"Error in instantiating ledger provider: unexpected format. db info = [leveldb at [%s]], data format = [], expected format = [2.0]",
 			stateLevelDBPath,
 		),
 		func() { env.initLedgerMgmt() },

core/ledger/kvledger/txmgmt/statedb/statecouchdb/statecouchdb.go

@@ -37,19 +37,6 @@ const (
 	dataformatVersionDocID = "dataformatVersion"
 )
 
-// ErrFormatVersionMismatch is returned if it is detected that the version of the format recorded in
-// the internal database is not "2.0"
-type ErrFormatVersionMismatch struct {
-	ExpectedFormatVersion string
-	DataFormatVersion     string
-}
-
-func (e *ErrFormatVersionMismatch) Error() string {
-	return fmt.Sprintf("unexpected format. data format = [%s], expected format = [%s]",
-		e.DataFormatVersion, e.ExpectedFormatVersion,
-	)
-}
-
 // VersionedDBProvider implements interface VersionedDBProvider
 type VersionedDBProvider struct {
 	couchInstance      *couchdb.CouchInstance
@@ -98,9 +85,10 @@ func checkExpectedDataformatVersion(couchInstance *couchdb.CouchInstance) error
 		return err
 	}
 	if dataformatVersion != dataformat.Version20 {
-		return &ErrFormatVersionMismatch{
-			ExpectedFormatVersion: dataformat.Version20,
-			DataFormatVersion:     dataformatVersion,
+		return &dataformat.ErrVersionMismatch{
+			DBInfo:          "CouchDB for state database",
+			ExpectedVersion: dataformat.Version20,
+			Version:         dataformatVersion,
 		}
 	}
 	return nil

core/ledger/kvledger/txmgmt/statedb/statecouchdb/statecouchdb_test.go

@@ -808,15 +808,19 @@ func assertQueryResults(t *testing.T, results []*couchdb.QueryResult, expectedId
 
 func TestFormatCheck(t *testing.T) {
 	testCases := []struct {
-		dataFormat     string                    // precondition
-		dataExists     bool                      // precondition
-		expectedFormat string                    // postcondition
-		expectedErr    *ErrFormatVersionMismatch // postcondition
+		dataFormat     string                         // precondition
+		dataExists     bool                           // precondition
+		expectedFormat string                         // postcondition
+		expectedErr    *dataformat.ErrVersionMismatch // postcondition
 	}{
 		{
-			dataFormat:     "",
-			dataExists:     true,
-			expectedErr:    &ErrFormatVersionMismatch{DataFormatVersion: "", ExpectedFormatVersion: "2.0"},
+			dataFormat: "",
+			dataExists: true,
+			expectedErr: &dataformat.ErrVersionMismatch{
+				DBInfo:          "CouchDB for state database",
+				Version:         "",
+				ExpectedVersion: "2.0",
+			},
 			expectedFormat: "does not matter as the test should not reach to check this",
 		},
 
@@ -842,9 +846,13 @@ func TestFormatCheck(t *testing.T) {
 		},
 
 		{
-			dataFormat:     "3.0",
-			dataExists:     true,
-			expectedErr:    &ErrFormatVersionMismatch{DataFormatVersion: "3.0", ExpectedFormatVersion: dataformat.Version20},
+			dataFormat: "3.0",
+			dataExists: true,
+			expectedErr: &dataformat.ErrVersionMismatch{
+				DBInfo:          "CouchDB for state database",
+				Version:         "3.0",
+				ExpectedVersion: dataformat.Version20,
+			},
 			expectedFormat: "does not matter as the test should not reach to check this",
 		},
 	}
@@ -858,7 +866,7 @@ func TestFormatCheck(t *testing.T) {
 	}
 }
 
-func testFormatCheck(t *testing.T, dataFormat string, dataExists bool, expectedErr *ErrFormatVersionMismatch, expectedFormat string) {
+func testFormatCheck(t *testing.T, dataFormat string, dataExists bool, expectedErr *dataformat.ErrVersionMismatch, expectedFormat string) {
 	redoPath, err := ioutil.TempDir("", "redoPath")
 	require.NoError(t, err)
 	defer os.RemoveAll(redoPath)

core/ledger/kvledger/upgrade_dbs_test.go

@@ -7,6 +7,7 @@ SPDX-License-Identifier: Apache-2.0
 package kvledger
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"testing"
@@ -76,7 +77,11 @@ func TestUpgradeIDStoreWrongFormat(t *testing.T) {
 	require.NoError(t, err)
 
 	err = UpgradeIDStoreFormat(conf.RootFSPath)
-	expectedErr := &leveldbhelper.ErrFormatVersionMismatch{ExpectedFormatVersion: "", DataFormatVersion: "x.0", DBPath: LedgerProviderPath(conf.RootFSPath)}
+	expectedErr := &dataformat.ErrVersionMismatch{
+		ExpectedVersion: "",
+		Version:         "x.0",
+		DBInfo:          fmt.Sprintf("leveldb for channel-IDs at [%s]", LedgerProviderPath(conf.RootFSPath)),
+	}
 	require.EqualError(t, err, expectedErr.Error())
 }