[FAB-4977] sidedb:statedb enhancements

This CR provides support for maintaining public, private, and hashed data
This includes
   - An interface for managing the three categories of data

   - A default implementation that allows the use of either
     leveldb or couchdb. The default implementation uses a
     single logical db and uses different namespaces for
     different categories of data. Alternate implementation
     based on furture need or exploration should be easy to support.
     These may include using different dbs for different categories
     such as using leveldb for hashed data and using separate dbs in
     a couch instance for public and private data

   - If the underlying db does not support storing random bytes as key
     (for example couch supports onlu valid utf-8 bytes as key), the
     key for the hashed data is encoded using base64

Change-Id: Ia8ede4f4c0ab392119e59bb7f46e9c20062a411a
Signed-off-by: manish <manish.sethi@gmail.com>

Author: manish-sethi

core/ledger/kvledger/txmgmt/privacyenabledstate/common_storage_db.go

@@ -0,0 +1,142 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package privacyenabledstate
+
+import (
+	"encoding/base64"
+	"fmt"
+
+	"github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/statedb"
+	"github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/statedb/statecouchdb"
+	"github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/statedb/stateleveldb"
+	"github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/version"
+	"github.com/hyperledger/fabric/core/ledger/ledgerconfig"
+)
+
+const (
+	nsJoiner       = "/"
+	pvtDataPrefix  = "p"
+	hashDataPrefix = "h"
+)
+
+// CommonStorageDBProvider implements interface DBProvider
+type CommonStorageDBProvider struct {
+	statedb.VersionedDBProvider
+}
+
+// NewCommonStorageDBProvider constructs an instance of DBProvider
+func NewCommonStorageDBProvider() (DBProvider, error) {
+	var vdbProvider statedb.VersionedDBProvider
+	var err error
+	if ledgerconfig.IsCouchDBEnabled() {
+		if vdbProvider, err = statecouchdb.NewVersionedDBProvider(); err != nil {
+			return nil, err
+		}
+	} else {
+		vdbProvider = stateleveldb.NewVersionedDBProvider()
+	}
+	return &CommonStorageDBProvider{vdbProvider}, nil
+}
+
+// GetDBHandle implements function from interface DBProvider
+func (p *CommonStorageDBProvider) GetDBHandle(id string) (DB, error) {
+	vdb, err := p.VersionedDBProvider.GetDBHandle(id)
+	if err != nil {
+		return nil, err
+	}
+	return NewCommonStorageDB(vdb, id)
+}
+
+// Close implements function from interface DBProvider
+func (p *CommonStorageDBProvider) Close() {
+	p.VersionedDBProvider.Close()
+}
+
+// CommonStorageDB implements interface DB. This implementation uses a single database to maintain
+// both the public and private data
+type CommonStorageDB struct {
+	statedb.VersionedDB
+}
+
+// NewCommonStorageDB wraps a VersionedDB instance. The public data is managed directly by the wrapped versionedDB.
+// For managing the hashed data and private data, this implementation creates separate namespaces in the wrapped db
+func NewCommonStorageDB(vdb statedb.VersionedDB, ledgerid string) (DB, error) {
+	return &CommonStorageDB{VersionedDB: vdb}, nil
+}
+
+// GetPrivateData implements corresponding function in interface DB
+func (s *CommonStorageDB) GetPrivateData(namespace, collection, key string) (*statedb.VersionedValue, error) {
+	return s.GetState(derivePvtDataNs(namespace, collection), key)
+}
+
+// GetValueHash implements corresponding function in interface DB
+func (s *CommonStorageDB) GetValueHash(namespace, collection string, keyHash []byte) (*statedb.VersionedValue, error) {
+	keyHashStr := string(keyHash)
+	if !s.BytesKeySuppoted() {
+		keyHashStr = base64.StdEncoding.EncodeToString(keyHash)
+	}
+	return s.GetState(deriveHashedDataNs(namespace, collection), keyHashStr)
+}
+
+// GetPrivateDataMultipleKeys implements corresponding function in interface DB
+func (s *CommonStorageDB) GetPrivateDataMultipleKeys(namespace, collection string, keys []string) ([]*statedb.VersionedValue, error) {
+	return s.GetStateMultipleKeys(derivePvtDataNs(namespace, collection), keys)
+}
+
+// GetPrivateDataRangeScanIterator implements corresponding function in interface DB
+func (s *CommonStorageDB) GetPrivateDataRangeScanIterator(namespace, collection, startKey, endKey string) (statedb.ResultsIterator, error) {
+	return s.GetStateRangeScanIterator(derivePvtDataNs(namespace, collection), startKey, endKey)
+}
+
+// ExecuteQueryOnPrivateData implements corresponding function in interface DB
+func (s CommonStorageDB) ExecuteQueryOnPrivateData(namespace, collection, query string) (statedb.ResultsIterator, error) {
+	return s.ExecuteQuery(derivePvtDataNs(namespace, collection), query)
+}
+
+// ApplyUpdates overrides the funciton in statedb.VersionedDB and throws appropriate error message
+// Otherwise, somewhere in the code, usage of this function could lead to updating only public data.
+func (s *CommonStorageDB) ApplyUpdates(batch *statedb.UpdateBatch, height *version.Height) error {
+	return fmt.Errorf("This function should not be invoked on this type. Please invoke function 'ApplyPrivacyAwareUpdates'")
+}
+
+// ApplyPrivacyAwareUpdates implements corresponding function in interface DB
+func (s *CommonStorageDB) ApplyPrivacyAwareUpdates(updates *UpdateBatch, height *version.Height) error {
+	addPvtUpdates(updates.PubUpdates, updates.PvtUpdates)
+	addHashedUpdates(updates.PubUpdates, updates.HashUpdates, !s.BytesKeySuppoted())
+	return s.VersionedDB.ApplyUpdates(updates.PubUpdates.UpdateBatch, height)
+}
+
+func derivePvtDataNs(namespace, collection string) string {
+	return namespace + nsJoiner + pvtDataPrefix + collection
+}
+
+func deriveHashedDataNs(namespace, collection string) string {
+	return namespace + nsJoiner + hashDataPrefix + collection
+}
+
+func addPvtUpdates(pubUpdateBatch *PubUpdateBatch, pvtUpdateBatch *PvtUpdateBatch) {
+	for ns, nsBatch := range pvtUpdateBatch.UpdateMap {
+		for _, coll := range nsBatch.GetCollectionNames() {
+			for key, vv := range nsBatch.GetUpdates(coll) {
+				pubUpdateBatch.Update(derivePvtDataNs(ns, coll), key, vv)
+			}
+		}
+	}
+}
+
+func addHashedUpdates(pubUpdateBatch *PubUpdateBatch, hashedUpdateBatch *HashedUpdateBatch, base64Key bool) {
+	for ns, nsBatch := range hashedUpdateBatch.UpdateMap {
+		for _, coll := range nsBatch.GetCollectionNames() {
+			for key, vv := range nsBatch.GetUpdates(coll) {
+				if base64Key {
+					key = base64.StdEncoding.EncodeToString([]byte(key))
+				}
+				pubUpdateBatch.Update(deriveHashedDataNs(ns, coll), key, vv)
+			}
+		}
+	}
+}

core/ledger/kvledger/txmgmt/privacyenabledstate/db.go

@@ -0,0 +1,138 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package privacyenabledstate
+
+import (
+	"github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/statedb"
+	"github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/version"
+)
+
+// DBProvider provides handle to a PvtVersionedDB
+type DBProvider interface {
+	// GetDBHandle returns a handle to a PvtVersionedDB
+	GetDBHandle(id string) (DB, error)
+	// Close closes all the PvtVersionedDB instances and releases any resources held by VersionedDBProvider
+	Close()
+}
+
+// DB extends VersionedDB interface. This interface provides additional functions for managing private data state
+type DB interface {
+	statedb.VersionedDB
+	GetPrivateData(namespace, collection, key string) (*statedb.VersionedValue, error)
+	GetValueHash(namespace, collection string, keyHash []byte) (*statedb.VersionedValue, error)
+	GetPrivateDataMultipleKeys(namespace, collection string, keys []string) ([]*statedb.VersionedValue, error)
+	GetPrivateDataRangeScanIterator(namespace, collection, startKey, endKey string) (statedb.ResultsIterator, error)
+	ExecuteQueryOnPrivateData(namespace, collection, query string) (statedb.ResultsIterator, error)
+	ApplyPrivacyAwareUpdates(updates *UpdateBatch, height *version.Height) error
+}
+
+// UpdateBatch encapsulates the updates to Public, Private, and Hashed data.
+// This is expected to contain a consistent set of updates
+type UpdateBatch struct {
+	PubUpdates  *PubUpdateBatch
+	HashUpdates *HashedUpdateBatch
+	PvtUpdates  *PvtUpdateBatch
+}
+
+// PubUpdateBatch contains update for the public data
+type PubUpdateBatch struct {
+	*statedb.UpdateBatch
+}
+
+// HashedUpdateBatch contains updates for the hashes of the private data
+type HashedUpdateBatch struct {
+	UpdateMap
+}
+
+// PvtUpdateBatch contains updates for the private data
+type PvtUpdateBatch struct {
+	UpdateMap
+}
+
+// UpdateMap maintains entries of tuple <Namespace, UpdatesForNamespace>
+type UpdateMap map[string]nsBatch
+
+// nsBatch contains updates related to one namespace
+type nsBatch struct {
+	*statedb.UpdateBatch
+}
+
+// NewUpdateBatch creates and empty UpdateBatch
+func NewUpdateBatch() *UpdateBatch {
+	return &UpdateBatch{NewPubUpdateBatch(), NewHashedUpdateBatch(), NewPvtUpdateBatch()}
+}
+
+// NewPubUpdateBatch creates an empty PubUpdateBatch
+func NewPubUpdateBatch() *PubUpdateBatch {
+	return &PubUpdateBatch{statedb.NewUpdateBatch()}
+}
+
+// NewHashedUpdateBatch creates an empty HashedUpdateBatch
+func NewHashedUpdateBatch() *HashedUpdateBatch {
+	return &HashedUpdateBatch{make(map[string]nsBatch)}
+}
+
+// NewPvtUpdateBatch creates an empty PvtUpdateBatch
+func NewPvtUpdateBatch() *PvtUpdateBatch {
+	return &PvtUpdateBatch{make(map[string]nsBatch)}
+}
+
+// IsEmpty returns true if there exists any updates
+func (b UpdateMap) IsEmpty() bool {
+	return len(b) == 0
+}
+
+// Put sets the value in the batch for a given combination of namespace and collection name
+func (b UpdateMap) Put(ns, coll, key string, value []byte, version *version.Height) {
+	b.getOrCreateNsBatch(ns).Put(coll, key, value, version)
+}
+
+// Delete removes the entry from the batch for a given combination of namespace and collection name
+func (b UpdateMap) Delete(ns, coll, key string, version *version.Height) {
+	b.getOrCreateNsBatch(ns).Delete(coll, key, version)
+}
+
+// Get retrieves the value from the batch for a given combination of namespace and collection name
+func (b UpdateMap) Get(ns, coll, key string) *statedb.VersionedValue {
+	nsPvtBatch, ok := b[ns]
+	if !ok {
+		return nil
+	}
+	return nsPvtBatch.Get(coll, key)
+}
+
+func (nsb nsBatch) GetCollectionNames() []string {
+	return nsb.GetUpdatedNamespaces()
+}
+
+func (b UpdateMap) getOrCreateNsBatch(ns string) nsBatch {
+	batch, ok := b[ns]
+	if !ok {
+		batch = nsBatch{statedb.NewUpdateBatch()}
+		b[ns] = batch
+	}
+	return batch
+}
+
+// Contains returns true if the given <ns,coll,keyHash> tuple is present in the batch
+func (h HashedUpdateBatch) Contains(ns, coll string, keyHash []byte) bool {
+	nsBatch, ok := h.UpdateMap[ns]
+	if !ok {
+		return false
+	}
+	return nsBatch.Exists(coll, string(keyHash))
+}
+
+// Put overrides the function in UpdateMap for allowing the key to be a []byte instead of a string
+func (h HashedUpdateBatch) Put(ns, coll string, key []byte, value []byte, version *version.Height) {
+	h.UpdateMap.Put(ns, coll, string(key), value, version)
+}
+
+// Delete overrides the function in UpdateMap for allowing the key to be a []byte instead of a string
+func (h HashedUpdateBatch) Delete(ns, coll string, key []byte, version *version.Height) {
+	h.UpdateMap.Delete(ns, coll, string(key), version)
+}