[FAB-2448] Add standard values proto initializer

https://jira.hyperledger.org/browse/FAB-2448

The proposer framework specifies a handler interface which requires
Allocate to create the backing resources necessary to handle
unmarshaling config and to map the config keys to the correct proto
structure.

This provides nice flexibility for arbitrary configuration, but, in
reality, all config is instantiated in almost the same way.

This CR adds a standard values proto intializer which will, given a
struct whose fields are proto messages, will build the config map based
on the field names, and allocate the memory necessary to unmarshal into
the struct.  This should help remove significant amounts of code as the
assorted config handlers are moved to the Proposer framework.

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

Author: Jason Yellick

common/configvalues/root/standardvalues.go

@@ -0,0 +1,92 @@
+/*
+Copyright IBM Corp. 2017 All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+                 http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package config
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/golang/protobuf/proto"
+)
+
+type standardValues struct {
+	lookup map[string]proto.Message
+}
+
+// NewStandardValues accepts a structure which must contain only protobuf message
+// types.  The structure may embed other (non-pointer) structures which satisfy
+// the same condition.  NewStandard values will instantiate memory for all the proto
+// messages and build a lookup map from structure field name to proto message instance
+// This is a useful way to easily implement the Values interface
+func NewStandardValues(protosStructs ...interface{}) (*standardValues, error) {
+	sv := &standardValues{
+		lookup: make(map[string]proto.Message),
+	}
+
+	for _, protosStruct := range protosStructs {
+		if err := sv.initializeProtosStruct(reflect.ValueOf(protosStruct)); err != nil {
+			return nil, err
+		}
+	}
+
+	return sv, nil
+}
+
+func (sv *standardValues) ProtoMsg(key string) (proto.Message, bool) {
+	msg, ok := sv.lookup[key]
+	return msg, ok
+}
+
+func (sv *standardValues) initializeProtosStruct(objValue reflect.Value) error {
+	objType := objValue.Type()
+	if objType.Kind() != reflect.Ptr {
+		return fmt.Errorf("Non pointer type")
+	}
+	if objType.Elem().Kind() != reflect.Struct {
+		return fmt.Errorf("Non struct type")
+	}
+
+	numFields := objValue.Elem().NumField()
+	for i := 0; i < numFields; i++ {
+		structField := objType.Elem().Field(i)
+		fmt.Printf("Processing field: %s\n", structField.Name)
+		switch structField.Type.Kind() {
+		case reflect.Ptr:
+			fieldPtr := objValue.Elem().Field(i)
+			if !fieldPtr.CanSet() {
+				return fmt.Errorf("Cannot set structure field %s (unexported?)", structField)
+			}
+			fieldPtr.Set(reflect.New(structField.Type.Elem()))
+		default:
+			return fmt.Errorf("Bad type supplied: %s", structField.Type.Kind())
+		}
+
+		proto, ok := objValue.Elem().Field(i).Interface().(proto.Message)
+		if !ok {
+			return fmt.Errorf("Field type %T does not implement proto.Message", objValue.Elem().Field(i))
+		}
+
+		_, ok = sv.lookup[structField.Name]
+		if ok {
+			return fmt.Errorf("Ambiguous field name specified, multiple occurances of %s", structField.Name)
+		}
+
+		sv.lookup[structField.Name] = proto
+	}
+
+	return nil
+}

common/configvalues/root/standardvalues_test.go

@@ -0,0 +1,111 @@
+/*
+Copyright IBM Corp. 2017 All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+                 http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package config
+
+import (
+	"testing"
+
+	cb "github.com/hyperledger/fabric/protos/common"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type foo struct {
+	Msg1 *cb.Envelope
+	Msg2 *cb.Payload
+}
+
+type bar struct {
+	Msg3 *cb.Header
+}
+
+type conflict struct {
+	Msg1 *cb.Header
+}
+
+type nonProtos struct {
+	Msg   *cb.Envelope
+	Wrong string
+}
+
+type unexported struct {
+	msg *cb.Envelope
+}
+
+func TestSingle(t *testing.T) {
+	fooVal := &foo{}
+	sv, err := NewStandardValues(fooVal)
+	assert.NoError(t, err, "Valid non-nested structure provided")
+	assert.NotNil(t, fooVal.Msg1, "Should have initialized Msg1")
+	assert.NotNil(t, fooVal.Msg2, "Should have initialized Msg2")
+
+	msg1, ok := sv.ProtoMsg("Msg1")
+	assert.True(t, ok, "Should have found map entry")
+	assert.Equal(t, msg1, fooVal.Msg1, "Should be same entry")
+
+	msg2, ok := sv.ProtoMsg("Msg2")
+	assert.True(t, ok, "Should have found map entry")
+	assert.Equal(t, msg2, fooVal.Msg2, "Should be same entry")
+}
+
+func TestPair(t *testing.T) {
+	fooVal := &foo{}
+	barVal := &bar{}
+	sv, err := NewStandardValues(fooVal, barVal)
+	assert.NoError(t, err, "Valid non-nested structure provided")
+	assert.NotNil(t, fooVal.Msg1, "Should have initialized Msg1")
+	assert.NotNil(t, fooVal.Msg2, "Should have initialized Msg2")
+	assert.NotNil(t, barVal.Msg3, "Should have initialized Msg3")
+
+	msg1, ok := sv.ProtoMsg("Msg1")
+	assert.True(t, ok, "Should have found map entry")
+	assert.Equal(t, msg1, fooVal.Msg1, "Should be same entry")
+
+	msg2, ok := sv.ProtoMsg("Msg2")
+	assert.True(t, ok, "Should have found map entry")
+	assert.Equal(t, msg2, fooVal.Msg2, "Should be same entry")
+
+	msg3, ok := sv.ProtoMsg("Msg3")
+	assert.True(t, ok, "Should have found map entry")
+	assert.Equal(t, msg3, barVal.Msg3, "Should be same entry")
+}
+
+func TestNestingConflict(t *testing.T) {
+	_, err := NewStandardValues(&foo{}, &conflict{})
+	assert.Error(t, err, "Conflicting keys provided")
+}
+
+func TestNonProtosStruct(t *testing.T) {
+	_, err := NewStandardValues(&nonProtos{})
+	assert.Error(t, err, "Structure with non-struct non-proto fields provided")
+}
+
+func TestUnexportedField(t *testing.T) {
+	_, err := NewStandardValues(&unexported{})
+	assert.Error(t, err, "Structure with unexported fields")
+}
+
+func TestNonPointerParam(t *testing.T) {
+	_, err := NewStandardValues(foo{})
+	assert.Error(t, err, "Parameter must be pointer")
+}
+
+func TestPointerToNonStruct(t *testing.T) {
+	nonStruct := "foo"
+	_, err := NewStandardValues(&nonStruct)
+	assert.Error(t, err, "Pointer must be to a struct")
+}