[FAB-4871] Add consortium members to MSP Manager

The consortium members MSP definitions are currently being parsed, but
they are not being added to the MSP manager for the ordering system
channel.  This means that if a policy references an organization in a
consortium, then that policy will always evaluate to false.

This is a problem particularly for updates of the consortium members MSP
definitions.

This CR passes in a reference to the channel's MSP Manager, rather than
creating a new one for each consortium member.

Change-Id: Idab43296cdb8d7692d29dec7c5d268554722593f
Signed-off-by: Jason Yellick <[email protected]>

Author: Jason Yellick

common/config/channel.go

@@ -122,7 +122,7 @@ func (cg *ChannelGroup) NewGroup(group string) (ValueProposer, error) {
 	case OrdererGroupKey:
 		return NewOrdererGroup(cg.mspConfigHandler), nil
 	case ConsortiumsGroupKey:
-		return NewConsortiumsGroup(), nil
+		return NewConsortiumsGroup(cg.mspConfigHandler), nil
 	default:
 		return nil, fmt.Errorf("Disallowed channel group: %s", group)
 	}

common/config/channel_test.go

@@ -67,17 +67,17 @@ func TestChannelConfig(t *testing.T) {
 
 	ag := NewApplicationGroup(nil)
 	og := NewOrdererGroup(nil)
-	csg := NewConsortiumsGroup()
+	csg := NewConsortiumsGroup(nil)
 	good := make(map[string]ValueProposer)
 	good[ApplicationGroupKey] = ag
 	good[OrdererGroupKey] = og
 	good[ConsortiumsGroupKey] = csg
 
 	err := cc.Validate(nil, good)
 	assert.NoError(t, err, "Unexpected error validating good config groups")
-	err = cc.Validate(nil, map[string]ValueProposer{ApplicationGroupKey: NewConsortiumsGroup()})
+	err = cc.Validate(nil, map[string]ValueProposer{ApplicationGroupKey: NewConsortiumsGroup(nil)})
 	assert.Error(t, err, "Expected error validating bad config group")
-	err = cc.Validate(nil, map[string]ValueProposer{OrdererGroupKey: NewConsortiumsGroup()})
+	err = cc.Validate(nil, map[string]ValueProposer{OrdererGroupKey: NewConsortiumsGroup(nil)})
 	assert.Error(t, err, "Expected error validating bad config group")
 	err = cc.Validate(nil, map[string]ValueProposer{ConsortiumsGroupKey: NewOrdererGroup(nil)})
 	assert.Error(t, err, "Expected error validating bad config group")

common/config/consortium.go

@@ -33,15 +33,13 @@ type ConsortiumGroup struct {
 	*Proposer
 	*ConsortiumConfig
 
-	mspConfig        *msp.MSPConfigHandler
-	consortiumsGroup *ConsortiumsGroup
+	mspConfig *msp.MSPConfigHandler
 }
 
 // NewConsortiumGroup creates a new *ConsortiumGroup
-func NewConsortiumGroup(consortiumsGroup *ConsortiumsGroup) *ConsortiumGroup {
+func NewConsortiumGroup(mspConfig *msp.MSPConfigHandler) *ConsortiumGroup {
 	cg := &ConsortiumGroup{
-		mspConfig:        msp.NewMSPConfigHandler(),
-		consortiumsGroup: consortiumsGroup,
+		mspConfig: mspConfig,
 	}
 	cg.Proposer = NewProposer(cg)
 	return cg
@@ -59,28 +57,21 @@ func (cg *ConsortiumGroup) Allocate() Values {
 
 // BeginValueProposals calls through to Proposer after calling into the MSP config Handler
 func (cg *ConsortiumGroup) BeginValueProposals(tx interface{}, groups []string) (ValueDeserializer, []ValueProposer, error) {
-	cg.mspConfig.BeginConfig(tx)
 	return cg.Proposer.BeginValueProposals(tx, groups)
 }
 
 // PreCommit intercepts the precommit request and commits the MSP config handler before calling the underlying proposer
 func (cg *ConsortiumGroup) PreCommit(tx interface{}) error {
-	err := cg.mspConfig.PreCommit(tx)
-	if err != nil {
-		return err
-	}
 	return cg.Proposer.PreCommit(tx)
 }
 
 // RollbackProposals intercepts the rollback request and commits the MSP config handler before calling the underlying proposer
 func (cg *ConsortiumGroup) RollbackProposals(tx interface{}) {
-	cg.mspConfig.RollbackProposals(tx)
 	cg.Proposer.RollbackProposals(tx)
 }
 
 // CommitProposals intercepts the commit request and commits the MSP config handler before calling the underlying proposer
 func (cg *ConsortiumGroup) CommitProposals(tx interface{}) {
-	cg.mspConfig.CommitProposals(tx)
 	cg.Proposer.CommitProposals(tx)
 }
 

common/config/consortium_test.go

@@ -18,13 +18,14 @@ package config
 import (
 	"testing"
 
+	"github.com/hyperledger/fabric/common/config/msp"
 	cb "github.com/hyperledger/fabric/protos/common"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestConsortiumGroup(t *testing.T) {
 
-	cg := NewConsortiumGroup(nil)
+	cg := NewConsortiumGroup(msp.NewMSPConfigHandler())
 	og, err := cg.NewGroup("testGroup")
 	assert.NoError(t, err, "NewGroup should not have returned error")
 	assert.Equal(t, "testGroup", og.(*OrganizationGroup).Name(),
@@ -45,7 +46,7 @@ func TestConsortiumGroup(t *testing.T) {
 }
 
 func TestConsortiumConfig(t *testing.T) {
-	cg := NewConsortiumGroup(nil)
+	cg := NewConsortiumGroup(msp.NewMSPConfigHandler())
 	cc := NewConsortiumConfig(cg)
 	orgs := cc.Organizations()
 	assert.Equal(t, 0, len(orgs))
@@ -61,7 +62,7 @@ func TestConsortiumConfig(t *testing.T) {
 		"testGroup": og,
 	})
 	assert.NoError(t, err, "Validate returned unexpected error")
-	csg := NewConsortiumsGroup()
+	csg := NewConsortiumsGroup(nil)
 	err = cc.Validate(t, map[string]ValueProposer{
 		"testGroup": csg,
 	})

common/config/consortiums.go

@@ -18,6 +18,8 @@ package config
 
 import (
 	"fmt"
+
+	"github.com/hyperledger/fabric/common/config/msp"
 )
 
 const (
@@ -29,18 +31,22 @@ const (
 type ConsortiumsGroup struct {
 	*Proposer
 	*ConsortiumsConfig
+
+	mspConfig *msp.MSPConfigHandler
 }
 
 // NewConsortiumsGroup creates a new *ConsortiumsGroup
-func NewConsortiumsGroup() *ConsortiumsGroup {
-	cg := &ConsortiumsGroup{}
+func NewConsortiumsGroup(mspConfig *msp.MSPConfigHandler) *ConsortiumsGroup {
+	cg := &ConsortiumsGroup{
+		mspConfig: mspConfig,
+	}
 	cg.Proposer = NewProposer(cg)
 	return cg
 }
 
 // NewGroup returns a Consortium instance
 func (cg *ConsortiumsGroup) NewGroup(name string) (ValueProposer, error) {
-	return NewConsortiumGroup(cg), nil
+	return NewConsortiumGroup(cg.mspConfig), nil
 }
 
 // Allocate returns the resources for a new config proposal

common/config/consortiums_test.go

@@ -23,7 +23,7 @@ import (
 
 func TestConsortiums(t *testing.T) {
 
-	csg := NewConsortiumsGroup()
+	csg := NewConsortiumsGroup(nil)
 	cg, err := csg.NewGroup("testCG")
 	assert.NoError(t, err, "NewGroup shuld not have returned error")
 	_, ok := cg.(*ConsortiumGroup)