[FAB-10178] Add Capabilities to Channel Config

Added capabilities to Channel Config. Users can
query the channel config whether or not a
capability is supported for a particular config
group.

Change-Id: I758036401bebb9223b84319c51f8c75b52a374e5
Signed-off-by: Bob Stasyszyn <Bob.Stasyszyn@securekey.com>

Author: bstasyszyn

pkg/common/providers/fab/channel.go

@@ -27,6 +27,25 @@ type ChannelConfig interface {
 	Query(reqCtx reqContext.Context) (ChannelCfg, error)
 }
 
+// ConfigGroupKey is the config group key
+type ConfigGroupKey string
+
+const (
+	// ChannelGroupKey is the Channel config group key
+	ChannelGroupKey ConfigGroupKey = ""
+	// OrdererGroupKey is the Orderer config group key
+	OrdererGroupKey ConfigGroupKey = "Orderer"
+	// ApplicationGroupKey is the Application config group key
+	ApplicationGroupKey ConfigGroupKey = "Application"
+)
+
+const (
+	// V1_1Capability indicates that Fabric 1.1 features are supported
+	V1_1Capability = "V1_1"
+	// V1_2Capability indicates that Fabric 1.2 features are supported
+	V1_2Capability = "V1_2"
+)
+
 // ChannelCfg contains channel configuration
 type ChannelCfg interface {
 	ID() string
@@ -35,6 +54,7 @@ type ChannelCfg interface {
 	AnchorPeers() []*OrgAnchorPeer
 	Orderers() []string
 	Versions() *Versions
+	HasCapability(group ConfigGroupKey, capability string) bool
 }
 
 // ChannelMembership helps identify a channel's members

pkg/fab/chconfig/chconfig.go

@@ -65,12 +65,13 @@ type ChannelConfig struct {
 
 // ChannelCfg contains channel configuration
 type ChannelCfg struct {
-	id          string
-	blockNumber uint64
-	msps        []*mb.MSPConfig
-	anchorPeers []*fab.OrgAnchorPeer
-	orderers    []string
-	versions    *fab.Versions
+	id           string
+	blockNumber  uint64
+	msps         []*mb.MSPConfig
+	anchorPeers  []*fab.OrgAnchorPeer
+	orderers     []string
+	versions     *fab.Versions
+	capabilities map[fab.ConfigGroupKey]map[string]bool
 }
 
 // NewChannelCfg creates channel cfg
@@ -109,6 +110,22 @@ func (cfg *ChannelCfg) Versions() *fab.Versions {
 	return cfg.versions
 }
 
+// HasCapability indicates whether or not the given group has the given capability
+func (cfg *ChannelCfg) HasCapability(group fab.ConfigGroupKey, capability string) bool {
+	groupCapabilities, ok := cfg.capabilities[group]
+	if !ok {
+		return false
+	}
+	if groupCapabilities[capability] {
+		return true
+	}
+	if capability == fab.V1_1Capability {
+		// If V1_2 capability is supported then V1_1 is also supported
+		return groupCapabilities[fab.V1_2Capability]
+	}
+	return false
+}
+
 // New channel config implementation
 func New(channelID string, options ...Option) (*ChannelConfig, error) {
 	opts, err := prepareOpts(options...)
@@ -130,7 +147,6 @@ func (c *ChannelConfig) Query(reqCtx reqContext.Context) (fab.ChannelCfg, error)
 }
 
 func (c *ChannelConfig) queryPeers(reqCtx reqContext.Context) (*ChannelCfg, error) {
-
 	ctx, ok := contextImpl.RequestClientContext(reqCtx)
 	if !ok {
 		return nil, errors.New("failed get client context from reqContext for signPayload")
@@ -351,15 +367,16 @@ func extractConfig(channelID string, block *common.Block) (*ChannelCfg, error) {
 	}
 
 	config := &ChannelCfg{
-		id:          channelID,
-		blockNumber: block.Header.Number,
-		msps:        []*mb.MSPConfig{},
-		anchorPeers: []*fab.OrgAnchorPeer{},
-		orderers:    []string{},
-		versions:    versions,
+		id:           channelID,
+		blockNumber:  block.Header.Number,
+		msps:         []*mb.MSPConfig{},
+		anchorPeers:  []*fab.OrgAnchorPeer{},
+		orderers:     []string{},
+		versions:     versions,
+		capabilities: make(map[fab.ConfigGroupKey]map[string]bool),
 	}
 
-	err = loadConfig(config, config.versions.Channel, group, "base", "")
+	err = loadConfig(config, config.versions.Channel, group, "", "")
 	if err != nil {
 		return nil, errors.WithMessage(err, "load config items from config group failed")
 	}
@@ -387,7 +404,7 @@ func loadConfig(configItems *ChannelCfg, versionsGroup *common.ConfigGroup, grou
 			logger.Debugf("loadConfigGroup - %s - found config group ==> %s", name, key)
 			// The Application group is where config settings are that we want to find
 			versionsGroup.Groups[key] = &common.ConfigGroup{}
-			err := loadConfig(configItems, versionsGroup.Groups[key], configGroup, name+"."+key, key)
+			err := loadConfig(configItems, versionsGroup.Groups[key], configGroup, key, key)
 			if err != nil {
 				return err
 			}
@@ -540,6 +557,21 @@ func loadOrdererAddressesKey(configValue *common.ConfigValue, configItems *Chann
 
 }
 
+func loadCapabilities(configValue *common.ConfigValue, configItems *ChannelCfg, groupName string) error {
+	capabilities := &common.Capabilities{}
+	err := proto.Unmarshal(configValue.Value, capabilities)
+	if err != nil {
+		return errors.Wrap(err, "unmarshal capabilities from config failed")
+	}
+	capabilityMap := make(map[string]bool)
+	for capability := range capabilities.Capabilities {
+		logger.Debugf("Adding capability for group [%s]: [%s]", groupName, capability)
+		capabilityMap[capability] = true
+	}
+	configItems.capabilities[fab.ConfigGroupKey(groupName)] = capabilityMap
+	return nil
+}
+
 func loadConfigValue(configItems *ChannelCfg, key string, versionsValue *common.ConfigValue, configValue *common.ConfigValue, groupName string, org string) error {
 	logger.Debugf("loadConfigValue - %s - START value name: %s", groupName, key)
 	logger.Debugf("loadConfigValue - %s   - version: %d", groupName, configValue.Version)
@@ -556,6 +588,10 @@ func loadConfigValue(configItems *ChannelCfg, key string, versionsValue *common.
 		if err := loadMSPKey(configValue, configItems, groupName); err != nil {
 			return err
 		}
+	case channelConfig.CapabilitiesKey:
+		if err := loadCapabilities(configValue, configItems, groupName); err != nil {
+			return err
+		}
 	//case channelConfig.ConsensusTypeKey:
 	//	consensusType := &ab.ConsensusType{}
 	//	err := proto.Unmarshal(configValue.Value, consensusType)

pkg/fab/chconfig/chconfig_test.go

@@ -26,6 +26,7 @@ import (
 	"github.com/hyperledger/fabric-sdk-go/pkg/core/config"
 	fabImpl "github.com/hyperledger/fabric-sdk-go/pkg/fab"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -233,6 +234,39 @@ func TestResolveOptsDefaultValuesWithInvalidChannel(t *testing.T) {
 	testResolveOptsDefaultValues(t, "INVALID-CHANNEL-ID")
 }
 
+func TestCapabilities(t *testing.T) {
+	capability1 := fab.V1_1Capability
+	capability2 := fab.V1_2Capability
+	capability3 := "V1_1_PVTDATA_EXPERIMENTAL"
+	capability4 := "V1_1_RESOURCETREE_EXPERIMENTAL"
+
+	builder := &mocks.MockConfigBlockBuilder{
+		MockConfigGroupBuilder: mocks.MockConfigGroupBuilder{
+			ModPolicy: "Admins",
+			MSPNames: []string{
+				"Org1MSP",
+				"Org2MSP",
+			},
+			OrdererAddress:          "localhost:9999",
+			RootCA:                  validRootCA,
+			ChannelCapabilities:     []string{capability1},
+			OrdererCapabilities:     []string{capability1},
+			ApplicationCapabilities: []string{capability2, capability3},
+		},
+		Index:           0,
+		LastConfigIndex: 0,
+	}
+
+	chConfig, err := extractConfig("mychannel", builder.Build())
+	require.NoError(t, err)
+
+	assert.Truef(t, chConfig.HasCapability(fab.ChannelGroupKey, capability1), "expecting channel capability [%s]", capability1)
+	assert.Truef(t, chConfig.HasCapability(fab.OrdererGroupKey, capability1), "expecting orderer capability [%s]", capability1)
+	assert.Truef(t, chConfig.HasCapability(fab.ApplicationGroupKey, capability2), "expecting application capability [%s]", capability2)
+	assert.Truef(t, chConfig.HasCapability(fab.ApplicationGroupKey, capability3), "expecting application capability [%s]", capability3)
+	assert.Falsef(t, chConfig.HasCapability(fab.ApplicationGroupKey, capability4), "not expecting application capability [%s]", capability4)
+}
+
 func testResolveOptsDefaultValues(t *testing.T, channelID string) {
 	user := mspmocks.NewMockSigningIdentity("test", "test")
 	ctx := mocks.NewMockContext(user)

pkg/fab/mocks/mockchconfig.go

@@ -16,18 +16,27 @@ import (
 
 // MockChannelCfg contains mock channel configuration
 type MockChannelCfg struct {
-	MockID          string
-	MockBlockNumber uint64
-	MockMSPs        []*msp.MSPConfig
-	MockAnchorPeers []*fab.OrgAnchorPeer
-	MockOrderers    []string
-	MockVersions    *fab.Versions
-	MockMembership  fab.ChannelMembership
+	MockID           string
+	MockBlockNumber  uint64
+	MockMSPs         []*msp.MSPConfig
+	MockAnchorPeers  []*fab.OrgAnchorPeer
+	MockOrderers     []string
+	MockVersions     *fab.Versions
+	MockMembership   fab.ChannelMembership
+	MockCapabilities map[fab.ConfigGroupKey]map[string]bool
 }
 
 // NewMockChannelCfg ...
 func NewMockChannelCfg(id string) *MockChannelCfg {
-	return &MockChannelCfg{MockID: id}
+	capabilities := make(map[fab.ConfigGroupKey]map[string]bool)
+	capabilities[fab.ChannelGroupKey] = make(map[string]bool)
+	capabilities[fab.ApplicationGroupKey] = make(map[string]bool)
+	capabilities[fab.OrdererGroupKey] = make(map[string]bool)
+
+	return &MockChannelCfg{
+		MockID:           id,
+		MockCapabilities: capabilities,
+	}
 }
 
 // ID returns name
@@ -60,6 +69,15 @@ func (cfg *MockChannelCfg) Versions() *fab.Versions {
 	return cfg.MockVersions
 }
 
+// HasCapability indicates whether or not the given group has the given capability
+func (cfg *MockChannelCfg) HasCapability(group fab.ConfigGroupKey, capability string) bool {
+	capabilities, ok := cfg.MockCapabilities[group]
+	if !ok {
+		return false
+	}
+	return capabilities[capability]
+}
+
 // MockChannelConfig mockcore query channel configuration
 type MockChannelConfig struct {
 	channelID string

pkg/fab/mocks/mockdata.go

@@ -53,12 +53,15 @@ func NewMockGenesisBlock() *common.Block {
 
 // MockConfigGroupBuilder is used to build a mock ConfigGroup
 type MockConfigGroupBuilder struct {
-	Version        uint64
-	ModPolicy      string
-	OrdererAddress string
-	MSPNames       []string
-	RootCA         string
-	Groups         map[string]*common.ConfigGroup
+	Version                 uint64
+	ModPolicy               string
+	OrdererAddress          string
+	MSPNames                []string
+	RootCA                  string
+	Groups                  map[string]*common.ConfigGroup
+	ChannelCapabilities     []string
+	ApplicationCapabilities []string
+	OrdererCapabilities     []string
 }
 
 // MockConfigBlockBuilder is used to build a mock Chain configuration block
@@ -180,6 +183,7 @@ func (b *MockConfigGroupBuilder) buildConfigGroup() *common.ConfigGroup {
 		},
 		Values: map[string]*common.ConfigValue{
 			channelConfig.OrdererAddressesKey: b.buildOrdererAddressesConfigValue(),
+			channelConfig.CapabilitiesKey:     b.buildCapabilitiesConfigValue(b.ChannelCapabilities),
 		},
 		Version:   b.Version,
 		ModPolicy: b.ModPolicy,
@@ -218,6 +222,7 @@ func (b *MockConfigGroupBuilder) buildOrdererGroup() *common.ConfigGroup {
 			channelConfig.ChannelRestrictionsKey:       b.buildChannelRestrictionsConfigValue(),
 			channelConfig.HashingAlgorithmKey:          b.buildHashingAlgorithmConfigValue(),
 			channelConfig.BlockDataHashingStructureKey: b.buildBlockDataHashingStructureConfigValue(),
+			channelConfig.CapabilitiesKey:              b.buildCapabilitiesConfigValue(b.OrdererCapabilities),
 		},
 		Version:   b.Version,
 		ModPolicy: b.ModPolicy,
@@ -297,6 +302,13 @@ func (b *MockConfigGroupBuilder) buildBlockDataHashingStructureConfigValue() *co
 		Value:     marshalOrPanic(b.buildBlockDataHashingStructure())}
 }
 
+func (b *MockConfigGroupBuilder) buildCapabilitiesConfigValue(capabilityNames []string) *common.ConfigValue {
+	return &common.ConfigValue{
+		Version:   b.Version,
+		ModPolicy: b.ModPolicy,
+		Value:     marshalOrPanic(b.buildCapabilities(capabilityNames))}
+}
+
 func (b *MockConfigGroupBuilder) buildBatchSize() *ab.BatchSize {
 	return &ab.BatchSize{
 		MaxMessageCount:   10,
@@ -342,6 +354,16 @@ func (b *MockConfigGroupBuilder) buildBlockDataHashingStructure() *common.BlockD
 	}
 }
 
+func (b *MockConfigGroupBuilder) buildCapabilities(capabilityNames []string) *common.Capabilities {
+	capabilities := make(map[string]*common.Capability)
+	for _, capability := range capabilityNames {
+		capabilities[capability] = &common.Capability{}
+	}
+	return &common.Capabilities{
+		Capabilities: capabilities,
+	}
+}
+
 func (b *MockConfigGroupBuilder) buildMSPConfig(name string) *mb.MSPConfig {
 	return &mb.MSPConfig{
 		Type:   0,
@@ -406,7 +428,8 @@ func (b *MockConfigGroupBuilder) buildApplicationGroup() *common.ConfigGroup {
 			"Readers": b.buildSignatureConfigPolicy(),
 		},
 		Values: map[string]*common.ConfigValue{
-			channelConfig.BatchSizeKey: b.buildBatchSizeConfigValue(),
+			channelConfig.BatchSizeKey:    b.buildBatchSizeConfigValue(),
+			channelConfig.CapabilitiesKey: b.buildCapabilitiesConfigValue(b.ApplicationCapabilities),
 			// TODO: More
 		},
 		Version:   b.Version,