fixup! refactor(fabric): remove import of common/channelconfig

Signed-off-by: Marcus Brandenburger <bur@zurich.ibm.com>

Author: mbrandenburger

platform/fabric/core/generic/membership/channelconfig/acls.go

@@ -0,0 +1,42 @@
+/*
+Copyright State Street Corp. 2018 All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package channelconfig
+
+import (
+	pb "github.com/hyperledger/fabric-protos-go-apiv2/peer"
+)
+
+// aclsProvider provides mappings for resource to policy names
+type aclsProvider struct {
+	aclPolicyRefs map[string]string
+}
+
+func (ag *aclsProvider) PolicyRefForAPI(aclName string) string {
+	return ag.aclPolicyRefs[aclName]
+}
+
+// this translates policies to absolute paths if needed
+func newAPIsProvider(acls map[string]*pb.APIResource) *aclsProvider {
+	aclPolicyRefs := make(map[string]string)
+
+	for key, acl := range acls {
+		if len(acl.PolicyRef) == 0 {
+			continue
+		}
+		// If the policy is fully qualified, ie to /Channel/Application/Readers leave it alone
+		// otherwise, make it fully qualified referring to /Channel/Application/policyName
+		if acl.PolicyRef[0] != '/' {
+			aclPolicyRefs[key] = "/" + ChannelGroupKey + "/" + ApplicationGroupKey + "/" + acl.PolicyRef
+		} else {
+			aclPolicyRefs[key] = acl.PolicyRef
+		}
+	}
+
+	return &aclsProvider{
+		aclPolicyRefs: aclPolicyRefs,
+	}
+}

platform/fabric/core/generic/membership/channelconfig/acls_test.go

@@ -0,0 +1,81 @@
+/*
+Copyright State Street Corp. 2018 All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package channelconfig
+
+import (
+	"testing"
+
+	pb "github.com/hyperledger/fabric-protos-go-apiv2/peer"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	sampleAPI1Name      = "Foo"
+	sampleAPI1PolicyRef = "foo"
+
+	sampleAPI2Name      = "Bar"
+	sampleAPI2PolicyRef = "/Channel/foo"
+)
+
+var sampleAPIsProvider = map[string]*pb.APIResource{
+	sampleAPI1Name: {PolicyRef: sampleAPI1PolicyRef},
+	sampleAPI2Name: {PolicyRef: sampleAPI2PolicyRef},
+}
+
+func TestGreenAPIsPath(t *testing.T) {
+	ag := newAPIsProvider(sampleAPIsProvider)
+	require.NotNil(t, ag)
+
+	t.Run("PresentAPIs", func(t *testing.T) {
+		require.Equal(t, "/Channel/Application/"+sampleAPI1PolicyRef, ag.PolicyRefForAPI(sampleAPI1Name))
+		require.Equal(t, sampleAPI2PolicyRef, ag.PolicyRefForAPI(sampleAPI2Name))
+	})
+
+	t.Run("MissingAPIs", func(t *testing.T) {
+		require.Empty(t, ag.PolicyRefForAPI("missing"))
+	})
+}
+
+func TestNilACLs(t *testing.T) {
+	ccg := newAPIsProvider(nil)
+
+	require.NotNil(t, ccg)
+	require.NotNil(t, ccg.aclPolicyRefs)
+	require.Empty(t, ccg.aclPolicyRefs)
+}
+
+func TestEmptyACLs(t *testing.T) {
+	ccg := newAPIsProvider(map[string]*pb.APIResource{})
+
+	require.NotNil(t, ccg)
+	require.NotNil(t, ccg.aclPolicyRefs)
+	require.Empty(t, ccg.aclPolicyRefs)
+}
+
+func TestEmptyPolicyRef(t *testing.T) {
+	ars := map[string]*pb.APIResource{
+		"unsetAPI": {PolicyRef: ""},
+	}
+
+	ccg := newAPIsProvider(ars)
+
+	require.NotNil(t, ccg)
+	require.NotNil(t, ccg.aclPolicyRefs)
+	require.Empty(t, ccg.aclPolicyRefs)
+
+	ars = map[string]*pb.APIResource{
+		"unsetAPI": {PolicyRef: ""},
+		"setAPI":   {PolicyRef: sampleAPI2PolicyRef},
+	}
+
+	ccg = newAPIsProvider(ars)
+
+	require.NotNil(t, ccg)
+	require.NotNil(t, ccg.aclPolicyRefs)
+	require.NotEmpty(t, ccg.aclPolicyRefs)
+	require.NotContains(t, ccg.aclPolicyRefs, sampleAPI1Name)
+}

platform/fabric/core/generic/membership/channelconfig/application.go

@@ -8,6 +8,7 @@ package channelconfig
 
 import (
 	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/core/generic/membership/channelconfig/capabilities"
 	cb "github.com/hyperledger/fabric-protos-go-apiv2/common"
 	pb "github.com/hyperledger/fabric-protos-go-apiv2/peer"
 )
@@ -58,3 +59,15 @@ func NewApplicationConfig(appGroup *cb.ConfigGroup, mspConfig *MSPConfigHandler)
 func (ac *ApplicationConfig) Organizations() map[string]ApplicationOrg {
 	return ac.applicationOrgs
 }
+
+// Capabilities returns a map of capability name to Capability
+func (ac *ApplicationConfig) Capabilities() ApplicationCapabilities {
+	return capabilities.NewApplicationProvider(ac.protos.Capabilities.Capabilities)
+}
+
+// APIPolicyMapper returns a PolicyMapper that maps API names to policies
+func (ac *ApplicationConfig) APIPolicyMapper() PolicyMapper {
+	pm := newAPIsProvider(ac.protos.ACLs.Acls)
+
+	return pm
+}

platform/fabric/core/generic/membership/channelconfig/channel.go

@@ -14,6 +14,7 @@ import (
 	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/core/generic/membership/channelconfig/capabilities"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/msp"
 	"github.com/hyperledger/fabric-lib-go/bccsp"
+	"github.com/hyperledger/fabric-lib-go/bccsp/factory"
 	cb "github.com/hyperledger/fabric-protos-go-apiv2/common"
 )
 
@@ -43,6 +44,10 @@ const (
 
 // ChannelValues gives read only access to the channel configuration
 type ChannelValues interface {
+	// HashingAlgorithm returns the default algorithm to be used when hashing
+	// such as computing block hashes, and CreationPolicy digests
+	HashingAlgorithm() func(input []byte) []byte
+
 	// BlockDataHashingStructureWidth returns the width to use when constructing the
 	// Merkle tree to compute the BlockData hash
 	BlockDataHashingStructureWidth() uint32
@@ -54,6 +59,7 @@ type ChannelValues interface {
 
 // ChannelProtos is where the proposed configuration is unmarshaled into
 type ChannelProtos struct {
+	HashingAlgorithm          *cb.HashingAlgorithm
 	BlockDataHashingStructure *cb.BlockDataHashingStructure
 	OrdererAddresses          *cb.OrdererAddresses
 	Orderers                  *cb.Orderers
@@ -65,10 +71,13 @@ type ChannelProtos struct {
 type ChannelConfig struct {
 	protos *ChannelProtos
 
+	hashingAlgorithm func(input []byte) []byte
+
 	mspManager msp.MSPManager
 
-	appConfig     *ApplicationConfig
-	ordererConfig *OrdererConfig
+	appConfig         *ApplicationConfig
+	ordererConfig     *OrdererConfig
+	consortiumsConfig *ConsortiumsConfig
 }
 
 // NewChannelConfig creates a new ChannelConfig
@@ -96,8 +105,8 @@ func NewChannelConfig(channelGroup *cb.ConfigGroup, bccsp bccsp.BCCSP) (*Channel
 			cc.appConfig, err = NewApplicationConfig(group, mspConfigHandler)
 		case OrdererGroupKey:
 			cc.ordererConfig, err = NewOrdererConfig(group, mspConfigHandler, channelCapabilities)
-		case "Consortium":
-			// ignore
+		case ConsortiumsGroupKey:
+			cc.consortiumsConfig, err = NewConsortiumsConfig(group, mspConfigHandler)
 		default:
 			return nil, fmt.Errorf("disallowed channel group: %s", group)
 		}
@@ -128,6 +137,16 @@ func (cc *ChannelConfig) ApplicationConfig() *ApplicationConfig {
 	return cc.appConfig
 }
 
+// ConsortiumsConfig returns the consortium config associated with this channel if it exists
+func (cc *ChannelConfig) ConsortiumsConfig() *ConsortiumsConfig {
+	return cc.consortiumsConfig
+}
+
+// HashingAlgorithm returns a function pointer to the chain hashing algorithm
+func (cc *ChannelConfig) HashingAlgorithm() func(input []byte) []byte {
+	return cc.hashingAlgorithm
+}
+
 // BlockDataHashingStructureWidth returns the width to use when forming the block data hashing structure
 func (cc *ChannelConfig) BlockDataHashingStructureWidth() uint32 {
 	return cc.protos.BlockDataHashingStructure.Width
@@ -154,6 +173,7 @@ func (cc *ChannelConfig) Capabilities() ChannelCapabilities {
 // Validate inspects the generated configuration protos and ensures that the values are correct
 func (cc *ChannelConfig) Validate(channelCapabilities ChannelCapabilities) error {
 	for _, validator := range []func() error{
+		cc.validateHashingAlgorithm,
 		cc.validateBlockDataHashingStructure,
 	} {
 		if err := validator(); err != nil {
@@ -176,6 +196,35 @@ func (cc *ChannelConfig) Validate(channelCapabilities ChannelCapabilities) error
 	return nil
 }
 
+func (cc *ChannelConfig) validateHashingAlgorithm() error {
+	computeSHA256 := func(data []byte) (hash []byte) {
+		hash, err := factory.GetDefault().Hash(data, &bccsp.SHA256Opts{})
+		if err != nil {
+			panic(errors.Errorf("failed computing SHA3_256 on [% x]", data))
+		}
+		return
+	}
+
+	computeSHA3256 := func(data []byte) (hash []byte) {
+		hash, err := factory.GetDefault().Hash(data, &bccsp.SHA3_256Opts{})
+		if err != nil {
+			panic(errors.Errorf("Failed computing SHA3_256 on [% x]", data))
+		}
+		return
+	}
+
+	switch cc.protos.HashingAlgorithm.Name {
+	case bccsp.SHA256:
+		cc.hashingAlgorithm = computeSHA256
+	case bccsp.SHA3_256:
+		cc.hashingAlgorithm = computeSHA3256
+	default:
+		return errors.Errorf("unknown hashing algorithm type: %s", cc.protos.HashingAlgorithm.Name)
+	}
+
+	return nil
+}
+
 func (cc *ChannelConfig) validateBlockDataHashingStructure() error {
 	if cc.protos.BlockDataHashingStructure.Width != math.MaxUint32 {
 		return fmt.Errorf("BlockDataHashStructure width only supported at MaxUint32 in this version")

platform/fabric/core/generic/membership/channelconfig/consortium.go

@@ -0,0 +1,61 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package channelconfig
+
+import (
+	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
+	cb "github.com/hyperledger/fabric-protos-go-apiv2/common"
+)
+
+const (
+	// ChannelCreationPolicyKey is the key used in the consortium config to denote the policy
+	// to be used in evaluating whether a channel creation request is authorized
+	ChannelCreationPolicyKey = "ChannelCreationPolicy"
+)
+
+// ConsortiumProtos holds the config protos for the consortium config
+type ConsortiumProtos struct {
+	ChannelCreationPolicy *cb.Policy
+}
+
+// ConsortiumConfig holds the consortium's configuration information
+type ConsortiumConfig struct {
+	protos *ConsortiumProtos
+	orgs   map[string]Org
+}
+
+// NewConsortiumConfig creates a new instance of the consortium's config
+func NewConsortiumConfig(consortiumGroup *cb.ConfigGroup, mspConfig *MSPConfigHandler) (*ConsortiumConfig, error) {
+	cc := &ConsortiumConfig{
+		protos: &ConsortiumProtos{},
+		orgs:   make(map[string]Org),
+	}
+
+	if err := DeserializeProtoValuesFromGroup(consortiumGroup, cc.protos); err != nil {
+		return nil, errors.Wrap(err, "failed to deserialize values")
+	}
+
+	for orgName, orgGroup := range consortiumGroup.Groups {
+		var err error
+		if cc.orgs[orgName], err = NewOrganizationConfig(orgName, orgGroup, mspConfig); err != nil {
+			return nil, err
+		}
+	}
+
+	return cc, nil
+}
+
+// Organizations returns the set of organizations in the consortium
+func (cc *ConsortiumConfig) Organizations() map[string]Org {
+	return cc.orgs
+}
+
+// ChannelCreationPolicy returns the policy structure used to validate
+// the channel creation
+func (cc *ConsortiumConfig) ChannelCreationPolicy() *cb.Policy {
+	return cc.protos.ChannelCreationPolicy
+}

platform/fabric/core/generic/membership/channelconfig/consortium_test.go

@@ -0,0 +1,27 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+package channelconfig
+
+import (
+	"testing"
+
+	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/msp"
+	"github.com/hyperledger/fabric-lib-go/bccsp/sw"
+	cb "github.com/hyperledger/fabric-protos-go-apiv2/common"
+	"github.com/stretchr/testify/require"
+)
+
+func TestConsortiumConfig(t *testing.T) {
+	cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore())
+	require.NoError(t, err)
+	cc, err := NewConsortiumConfig(&cb.ConfigGroup{}, NewMSPConfigHandler(msp.MSPv1_0, cryptoProvider))
+	require.NoError(t, err)
+	orgs := cc.Organizations()
+	require.Equal(t, 0, len(orgs))
+
+	policy := cc.ChannelCreationPolicy()
+	require.EqualValues(t, cb.Policy_UNKNOWN, policy.Type, "Expected policy type to be UNKNOWN")
+}

platform/fabric/core/generic/membership/channelconfig/consortiums.go

@@ -0,0 +1,41 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package channelconfig
+
+import (
+	cb "github.com/hyperledger/fabric-protos-go-apiv2/common"
+)
+
+const (
+	// ConsortiumsGroupKey is the group name for the consortiums config
+	ConsortiumsGroupKey = "Consortiums"
+)
+
+// ConsortiumsConfig holds the consoritums configuration information
+type ConsortiumsConfig struct {
+	consortiums map[string]Consortium
+}
+
+// NewConsortiumsConfig creates a new instance of the consoritums config
+func NewConsortiumsConfig(consortiumsGroup *cb.ConfigGroup, mspConfig *MSPConfigHandler) (*ConsortiumsConfig, error) {
+	cc := &ConsortiumsConfig{
+		consortiums: make(map[string]Consortium),
+	}
+
+	for consortiumName, consortiumGroup := range consortiumsGroup.Groups {
+		var err error
+		if cc.consortiums[consortiumName], err = NewConsortiumConfig(consortiumGroup, mspConfig); err != nil {
+			return nil, err
+		}
+	}
+	return cc, nil
+}
+
+// Consortiums returns a map of the current consortiums
+func (cc *ConsortiumsConfig) Consortiums() map[string]Consortium {
+	return cc.consortiums
+}