[FAB-4105] Fab proto translation methods

With the work done for FAB-4100 through FAB-4104, it is now possible to
add a few small descriptive methods to proto methods, and the proto
translator framework can then transalte the binary proto (including
fields which would ordinarilly be expressed as binary, or nested binary)
into pure binary-less JSON.

This CR adds the methods necessary to annotate the fabric protos related
to configuration.  This now allows the proto translation framework to
print fully human readable versions of both config update messages, as
well as of configuration blocks (and any subset thereof).

This CR appears to introduce substantial amounts of code with very
little tests.  However, the two tests in blackbox_test use every method
introduced.  Additionally, because these methods are only used for proto
printing, they can have no affect on the stability of the fabric
overall.

This is a key component for FAB-1678.

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

Author: Jason Yellick

common/tools/protolator/blackbox_test.go

@@ -0,0 +1,70 @@
+/*
+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 protolator_test
+
+import (
+	"bytes"
+	"testing"
+
+	genesisconfig "github.com/hyperledger/fabric/common/configtx/tool/localconfig"
+	"github.com/hyperledger/fabric/common/configtx/tool/provisional"
+	. "github.com/hyperledger/fabric/common/tools/protolator"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/stretchr/testify/assert"
+)
+
+func bidirectionalMarshal(t *testing.T, doc proto.Message) {
+	var buffer bytes.Buffer
+
+	assert.NoError(t, DeepMarshalJSON(&buffer, doc))
+
+	newRoot := proto.Clone(doc)
+	newRoot.Reset()
+	assert.NoError(t, DeepUnmarshalJSON(bytes.NewReader(buffer.Bytes()), newRoot))
+
+	// Note, we cannot do an equality check between newRoot and sampleDoc
+	// because of the nondeterministic nature of binary proto marshaling
+	// So instead we re-marshal to JSON which is a deterministic marshaling
+	// and compare equality there instead
+
+	//t.Log(doc)
+	//t.Log(newRoot)
+
+	var remarshaled bytes.Buffer
+	assert.NoError(t, DeepMarshalJSON(&remarshaled, newRoot))
+	assert.Equal(t, string(buffer.Bytes()), string(remarshaled.Bytes()))
+	//t.Log(string(buffer.Bytes()))
+	//t.Log(string(remarshaled.Bytes()))
+}
+
+func TestConfigUpdate(t *testing.T) {
+	p := provisional.New(genesisconfig.Load(genesisconfig.SampleSingleMSPSoloProfile))
+	ct := p.ChannelTemplate()
+	cue, err := ct.Envelope("Foo")
+	assert.NoError(t, err)
+
+	bidirectionalMarshal(t, cue)
+}
+
+func TestGenesisBlock(t *testing.T) {
+	p := provisional.New(genesisconfig.Load(genesisconfig.SampleSingleMSPSoloProfile))
+	gb := p.GenesisBlockForChannel("foo")
+
+	bidirectionalMarshal(t, gb)
+
+}

common/tools/protolator/nested.go

@@ -20,6 +20,7 @@ import (
 	"reflect"
 
 	"github.com/golang/protobuf/proto"
+	"github.com/golang/protobuf/ptypes/timestamp"
 )
 
 func nestedFrom(value interface{}, destType reflect.Type) (reflect.Value, error) {
@@ -37,10 +38,14 @@ func nestedTo(value reflect.Value) (interface{}, error) {
 	return recursivelyCreateTreeFromMessage(nMsg)
 }
 
+var timestampType = reflect.TypeOf(&timestamp.Timestamp{})
+
 type nestedFieldFactory struct{}
 
 func (nff nestedFieldFactory) Handles(msg proto.Message, fieldName string, fieldType reflect.Type, fieldValue reflect.Value) bool {
-	return fieldType.Kind() == reflect.Ptr && fieldType.AssignableTo(protoMsgType)
+	// Note, we skip recursing into the field if it is a proto native timestamp, because there is other custom marshaling this conflicts with
+	// this should probably be revisited more generally to prevent custom marshaling of 'well known messages'
+	return fieldType.Kind() == reflect.Ptr && fieldType.AssignableTo(protoMsgType) && !fieldType.AssignableTo(timestampType)
 }
 
 func (nff nestedFieldFactory) NewProtoField(msg proto.Message, fieldName string, fieldType reflect.Type, fieldValue reflect.Value) (protoField, error) {
@@ -60,7 +65,7 @@ func (nff nestedFieldFactory) NewProtoField(msg proto.Message, fieldName string,
 type nestedMapFieldFactory struct{}
 
 func (nmff nestedMapFieldFactory) Handles(msg proto.Message, fieldName string, fieldType reflect.Type, fieldValue reflect.Value) bool {
-	return fieldType.Kind() == reflect.Map && fieldType.Elem().AssignableTo(protoMsgType)
+	return fieldType.Kind() == reflect.Map && fieldType.Elem().AssignableTo(protoMsgType) && !fieldType.Elem().AssignableTo(timestampType)
 }
 
 func (nmff nestedMapFieldFactory) NewProtoField(msg proto.Message, fieldName string, fieldType reflect.Type, fieldValue reflect.Value) (protoField, error) {
@@ -84,7 +89,7 @@ func (nmff nestedMapFieldFactory) NewProtoField(msg proto.Message, fieldName str
 type nestedSliceFieldFactory struct{}
 
 func (nmff nestedSliceFieldFactory) Handles(msg proto.Message, fieldName string, fieldType reflect.Type, fieldValue reflect.Value) bool {
-	return fieldType.Kind() == reflect.Slice && fieldType.Elem().AssignableTo(protoMsgType)
+	return fieldType.Kind() == reflect.Slice && fieldType.Elem().AssignableTo(protoMsgType) && !fieldType.Elem().AssignableTo(timestampType)
 }
 
 func (nmff nestedSliceFieldFactory) NewProtoField(msg proto.Message, fieldName string, fieldType reflect.Type, fieldValue reflect.Value) (protoField, error) {

protos/common/common.go

@@ -0,0 +1,88 @@
+/*
+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 common
+
+import (
+	"fmt"
+
+	"github.com/golang/protobuf/proto"
+)
+
+func (e *Envelope) StaticallyOpaqueFields() []string {
+	return []string{"payload"}
+}
+
+func (e *Envelope) StaticallyOpaqueFieldProto(name string) (proto.Message, error) {
+	if name != e.StaticallyOpaqueFields()[0] {
+		return nil, fmt.Errorf("not a marshaled field: %s", name)
+	}
+	return &Payload{}, nil
+}
+
+func (p *Payload) VariablyOpaqueFields() []string {
+	return []string{"data"}
+}
+
+func (p *Payload) VariablyOpaqueFieldProto(name string) (proto.Message, error) {
+	if name != p.VariablyOpaqueFields()[0] {
+		return nil, fmt.Errorf("not a marshaled field: %s", name)
+	}
+	if p.Header == nil {
+		return nil, fmt.Errorf("cannot determine payload type when header is missing")
+	}
+	ch := &ChannelHeader{}
+	if err := proto.Unmarshal(p.Header.ChannelHeader, ch); err != nil {
+		return nil, fmt.Errorf("corrupt channel header: %s", err)
+	}
+
+	switch ch.Type {
+	case int32(HeaderType_CONFIG):
+		return &ConfigEnvelope{}, nil
+	case int32(HeaderType_CONFIG_UPDATE):
+		return &ConfigUpdateEnvelope{}, nil
+	// TODO implement the other well known types, particularly endorser txs
+	default:
+		return nil, fmt.Errorf("decoding type %v is unimplemented", ch.Type)
+	}
+}
+
+func (h *Header) StaticallyOpaqueFields() []string {
+	return []string{"channel_header", "signature_header"}
+}
+
+func (h *Header) StaticallyOpaqueFieldProto(name string) (proto.Message, error) {
+	switch name {
+	case h.StaticallyOpaqueFields()[0]: // channel_header
+		return &ChannelHeader{}, nil
+	case h.StaticallyOpaqueFields()[1]: // signature_header
+		return &SignatureHeader{}, nil
+	default:
+		return nil, fmt.Errorf("unknown header field: %s", name)
+	}
+}
+
+func (bd *BlockData) StaticallyOpaqueSliceFields() []string {
+	return []string{"data"}
+}
+
+func (bd *BlockData) StaticallyOpaqueSliceFieldProto(fieldName string, index int) (proto.Message, error) {
+	if fieldName != bd.StaticallyOpaqueSliceFields()[0] {
+		return nil, fmt.Errorf("not an opaque slice field: %s", fieldName)
+	}
+
+	return &Envelope{}, nil
+}

protos/common/configtx.go

@@ -16,10 +16,92 @@ limitations under the License.
 
 package common
 
+import (
+	"fmt"
+
+	"github.com/golang/protobuf/proto"
+)
+
 func NewConfigGroup() *ConfigGroup {
 	return &ConfigGroup{
 		Groups:   make(map[string]*ConfigGroup),
 		Values:   make(map[string]*ConfigValue),
 		Policies: make(map[string]*ConfigPolicy),
 	}
 }
+
+func (cue *ConfigUpdateEnvelope) StaticallyOpaqueFields() []string {
+	return []string{"config_update"}
+}
+
+func (cue *ConfigUpdateEnvelope) StaticallyOpaqueFieldProto(name string) (proto.Message, error) {
+	if name != cue.StaticallyOpaqueFields()[0] {
+		return nil, fmt.Errorf("Not a marshaled field: %s", name)
+	}
+	return &ConfigUpdate{}, nil
+}
+
+func (cs *ConfigSignature) StaticallyOpaqueFields() []string {
+	return []string{"signature_header"}
+}
+
+func (cs *ConfigSignature) StaticallyOpaqueFieldProto(name string) (proto.Message, error) {
+	if name != cs.StaticallyOpaqueFields()[0] {
+		return nil, fmt.Errorf("Not a marshaled field: %s", name)
+	}
+	return &SignatureHeader{}, nil
+}
+
+func (c *Config) DynamicFields() []string {
+	return []string{"channel_group"}
+}
+
+func (c *Config) DynamicFieldProto(name string, base proto.Message) (proto.Message, error) {
+	if name != c.DynamicFields()[0] {
+		return nil, fmt.Errorf("Not a dynamic field: %s", name)
+	}
+
+	cg, ok := base.(*ConfigGroup)
+	if !ok {
+		return nil, fmt.Errorf("Config must embed a config group as its dynamic field")
+	}
+
+	return &DynamicChannelGroup{
+		ConfigGroup: cg,
+	}, nil
+}
+
+func (c *ConfigUpdate) DynamicFields() []string {
+	return []string{"read_set", "write_set"}
+}
+
+func (c *ConfigUpdate) DynamicFieldProto(name string, base proto.Message) (proto.Message, error) {
+	if name != c.DynamicFields()[0] && name != c.DynamicFields()[1] {
+		return nil, fmt.Errorf("Not a dynamic field: %s", name)
+	}
+
+	cg, ok := base.(*ConfigGroup)
+	if !ok {
+		return nil, fmt.Errorf("Expected base to be *ConfigGroup, got %T", base)
+	}
+
+	return &DynamicChannelGroup{
+		ConfigGroup: cg,
+	}, nil
+}
+
+func (cv *ConfigValue) VariablyOpaqueFields() []string {
+	return []string{"value"}
+}
+
+func (cv *ConfigValue) Underlying() proto.Message {
+	return cv
+}
+
+func (cg *ConfigGroup) DynamicMapFields() []string {
+	return []string{"groups", "values"}
+}
+
+func (cg *ConfigGroup) Underlying() proto.Message {
+	return cg
+}