[FAB-5815] Make resources config immutable

Although very recently introduced, the resources config followed the
same mutable model as the channel config.  This leads to some awkward
looking code with far  more lines than are actually needed.

This CR converts the resources config to follow the same bundle model
that the channel config does.  It does not intrduce a bundle source like
the channel config because for the moment, the resource config may not
be changed.

Change-Id: I35614c5f7f6bee3b9ab2848033a1834ef8c76383
Signed-off-by: Jason Yellick <jyellick@us.ibm.com>

Author: Jason Yellick

common/config/resources/initializer.go renamed to common/config/resources/bundle.go

@@ -10,10 +10,9 @@ import (
 	"fmt"
 
 	"github.com/hyperledger/fabric/common/cauthdsl"
-	newchannelconfig "github.com/hyperledger/fabric/common/channelconfig"
-	"github.com/hyperledger/fabric/common/config"
 	"github.com/hyperledger/fabric/common/configtx"
 	configtxapi "github.com/hyperledger/fabric/common/configtx/api"
+	"github.com/hyperledger/fabric/common/flogging"
 	"github.com/hyperledger/fabric/common/policies"
 	"github.com/hyperledger/fabric/msp"
 	cb "github.com/hyperledger/fabric/protos/common"
@@ -22,15 +21,25 @@ import (
 
 const RootGroupKey = "Resources"
 
+var logger = flogging.MustGetLogger("common/config/resource")
+
+// PolicyMapper is an interface for
+type PolicyMapper interface {
+	// PolicyRefForResource takes the name of a resource, and returns the policy name for a resource
+	// or the empty string is the resource is not found
+	PolicyRefForResource(resourceName string) string
+}
+
 type Bundle struct {
-	vpr *valueProposerRoot
+	rg  *resourceGroup
 	cm  configtxapi.Manager
 	pm  policies.Manager
 	rpm policies.Manager
 }
 
 // New creates a new resources config bundle
 // TODO, change interface to take config and not an envelope
+// TODO, add an atomic BundleSource
 func New(envConfig *cb.Envelope, mspManager msp.MSPManager, channelPolicyManager policies.Manager) (*Bundle, error) {
 	policyProviderMap := make(map[int32]policies.Provider)
 	for pType := range cb.Policy_PolicyType_name {
@@ -64,9 +73,14 @@ func New(envConfig *cb.Envelope, mspManager msp.MSPManager, channelPolicyManager
 		return nil, err
 	}
 
+	resourceGroup, err := newResourceGroup(configEnvelope.Config.ChannelGroup)
+	if err != nil {
+		return nil, err
+	}
+
 	b := &Bundle{
-		vpr: newValueProposerRoot(),
 		rpm: resourcesPolicyManager,
+		rg:  resourceGroup,
 		pm: &policyRouter{
 			channelPolicyManager:   channelPolicyManager,
 			resourcesPolicyManager: resourcesPolicyManager,
@@ -78,26 +92,13 @@ func New(envConfig *cb.Envelope, mspManager msp.MSPManager, channelPolicyManager
 		return nil, err
 	}
 
-	err = newchannelconfig.InitializeConfigValues(b.vpr, &cb.ConfigGroup{
-		Groups: map[string]*cb.ConfigGroup{
-			RootGroupKey: configEnvelope.Config.ChannelGroup,
-		},
-	})
-	if err != nil {
-		return nil, err
-	}
-
 	return b, nil
 }
 
 func (b *Bundle) RootGroupKey() string {
 	return RootGroupKey
 }
 
-func (b *Bundle) ValueProposer() config.ValueProposer {
-	return b.vpr
-}
-
 func (b *Bundle) ConfigtxManager() configtxapi.Manager {
 	return b.cm
 }
@@ -107,5 +108,5 @@ func (b *Bundle) PolicyManager() policies.Manager {
 }
 
 func (b *Bundle) ResourcePolicyMapper() PolicyMapper {
-	return b.vpr
+	return b.rg
 }

common/config/resources/initializer_test.go renamed to common/config/resources/bundle_test.go

@@ -69,7 +69,6 @@ func TestBundleGreenPath(t *testing.T) {
 
 	t.Run("Code coverage nits", func(t *testing.T) {
 		assert.Equal(t, b.RootGroupKey(), RootGroupKey)
-		assert.NotNil(t, b.ValueProposer())
 		assert.NotNil(t, b.ConfigtxManager())
 		assert.NotNil(t, b.PolicyManager())
 	})

common/config/resources/resources.go

@@ -7,83 +7,60 @@ SPDX-License-Identifier: Apache-2.0
 package resources
 
 import (
-	"github.com/hyperledger/fabric/common/config"
+	"fmt"
+
+	cb "github.com/hyperledger/fabric/protos/common"
 	pb "github.com/hyperledger/fabric/protos/peer"
 
 	"github.com/golang/protobuf/proto"
 )
 
 // ResourceGroup represents the ConfigGroup at the base of the resource configuration
 type resourceGroup struct {
-	pendingResourceToPolicyRef map[string]string
-	vpr                        *valueProposerRoot
-}
-
-func newResourceGroup(vpr *valueProposerRoot) *resourceGroup {
-	return &resourceGroup{
-		vpr: vpr,
-		pendingResourceToPolicyRef: make(map[string]string),
-	}
-}
-
-// BeginValueProposals is invoked for each sub-group.  These sub-groups are only for defining policies, not other config
-// so, an emptyGroup is returned to handle them
-func (rg *resourceGroup) BeginValueProposals(tx interface{}, groups []string) (config.ValueDeserializer, []config.ValueProposer, error) {
-	subGroups := make([]config.ValueProposer, len(groups))
-	for i := range subGroups {
-		subGroups[i] = emptyGroup{}
-	}
-	return &resourceGroupDeserializer{rg: rg}, subGroups, nil
-}
-
-// RollbackConfig a no-op
-func (rg *resourceGroup) RollbackProposals(tx interface{}) {}
-
-// PreCommit is a no-op
-func (rg *resourceGroup) PreCommit(tx interface{}) error { return nil }
-
-// CommitProposals writes the pendingResourceToPolicyRef map to the resource config root
-func (rg *resourceGroup) CommitProposals(tx interface{}) {
-	rg.vpr.updatePolicyRefForResources(rg.pendingResourceToPolicyRef)
+	resourcePolicyRefs map[string]string
 }
 
-type resourceGroupDeserializer struct {
-	rg *resourceGroup
+func (rg *resourceGroup) PolicyRefForResource(resourceName string) string {
+	return rg.resourcePolicyRefs[resourceName]
 }
 
-// Deserialize unmarshals bytes to a pb.Resource
-func (rgd *resourceGroupDeserializer) Deserialize(key string, value []byte) (proto.Message, error) {
-	resource := &pb.Resource{}
-	if err := proto.Unmarshal(value, resource); err != nil {
-		return nil, err
+func newResourceGroup(root *cb.ConfigGroup) (*resourceGroup, error) {
+	resourcePolicyRefs := make(map[string]string)
+
+	for key, value := range root.Values {
+		resource := &pb.Resource{}
+		if err := proto.Unmarshal(value.Value, resource); err != nil {
+			return nil, err
+		}
+
+		// If the policy is fully qualified, ie to /Channel/Application/Readers leave it alone
+		// otherwise, make it fully qualified referring to /Resources/policyName
+		if '/' != resource.PolicyRef[0] {
+			resourcePolicyRefs[key] = "/" + RootGroupKey + "/" + resource.PolicyRef
+		} else {
+			resourcePolicyRefs[key] = resource.PolicyRef
+		}
 	}
 
-	// If the policy is fully qualified, ie to /Channel/Application/Readers leave it alone
-	// otherwise, make it fully qualified referring to /Resources/policyName
-	if '/' != resource.PolicyRef[0] {
-		rgd.rg.pendingResourceToPolicyRef[key] = "/" + RootGroupKey + "/" + resource.PolicyRef
-	} else {
-		rgd.rg.pendingResourceToPolicyRef[key] = resource.PolicyRef
+	for _, subGroup := range root.Groups {
+		if err := verifyNoMoreValues(subGroup); err != nil {
+			return nil, err
+		}
 	}
 
-	return resource, nil
+	return &resourceGroup{
+		resourcePolicyRefs: resourcePolicyRefs,
+	}, nil
 }
 
-type emptyGroup struct{}
-
-func (eg emptyGroup) BeginValueProposals(tx interface{}, groups []string) (config.ValueDeserializer, []config.ValueProposer, error) {
-	subGroups := make([]config.ValueProposer, len(groups))
-	for i := range subGroups {
-		subGroups[i] = emptyGroup{}
+func verifyNoMoreValues(subGroup *cb.ConfigGroup) error {
+	if len(subGroup.Values) > 0 {
+		return fmt.Errorf("sub-groups not allowed to have values")
 	}
-	return failDeserializer("sub-groups not allowed to have values"), subGroups, nil
+	for _, subGroup := range subGroup.Groups {
+		if err := verifyNoMoreValues(subGroup); err != nil {
+			return err
+		}
+	}
+	return nil
 }
-
-// RollbackConfig a no-op
-func (eg emptyGroup) RollbackProposals(tx interface{}) {}
-
-// PreCommit is a no-op
-func (eg emptyGroup) PreCommit(tx interface{}) error { return nil }
-
-// CommitConfig is a no-op
-func (eg emptyGroup) CommitProposals(tx interface{}) {}