[FAB-2612] Enable configtxgen configtx inspection

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

FAB-2584 enabled the configtxgen tool to dump the configuration from a
config block.  This CR extends that functionality to the configtx for
channel creation as well.

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

Author: Jason Yellick

common/configtx/tool/configtxgen/main.go

@@ -37,79 +37,81 @@ import (
 
 var logger = logging.MustGetLogger("common/configtx/tool")
 
-func doOutputBlock(pgen provisional.Generator, channelID string, outputBlock string) {
+func doOutputBlock(pgen provisional.Generator, channelID string, outputBlock string) error {
 	logger.Info("Generating genesis block")
 	genesisBlock := pgen.GenesisBlockForChannel(channelID)
 	logger.Info("Writing genesis block")
 	err := ioutil.WriteFile(outputBlock, utils.MarshalOrPanic(genesisBlock), 0644)
 	if err != nil {
-		logger.Errorf("Error writing genesis block: %s", err)
+		return fmt.Errorf("Error writing genesis block: %s", err)
 	}
+	return nil
 }
 
-func doOutputChannelCreateTx(pgen provisional.Generator, channelID string, outputChannelCreateTx string) {
+func doOutputChannelCreateTx(pgen provisional.Generator, channelID string, outputChannelCreateTx string) error {
 	logger.Info("Generating new channel configtx")
 	// TODO, use actual MSP eventually
 	signer, err := msp.NewNoopMsp().GetDefaultSigningIdentity()
 	if err != nil {
-		logger.Fatalf("Error getting signing identity: %s", err)
+		return fmt.Errorf("Error getting signing identity: %s", err)
 	}
 	configtx, err := configtx.MakeChainCreationTransaction(provisional.AcceptAllPolicyKey, channelID, signer, pgen.ChannelTemplate())
 	if err != nil {
-		logger.Fatalf("Error generating configtx: %s", err)
+		return fmt.Errorf("Error generating configtx: %s", err)
 	}
 	logger.Info("Writing new channel tx")
 	err = ioutil.WriteFile(outputChannelCreateTx, utils.MarshalOrPanic(configtx), 0644)
 	if err != nil {
-		logger.Errorf("Error writing channel create tx: %s", err)
+		return fmt.Errorf("Error writing channel create tx: %s", err)
 	}
+	return nil
 }
 
-func doInspectBlock(inspectBlock string) {
+func doInspectBlock(inspectBlock string) error {
 	logger.Info("Inspecting block")
 	data, err := ioutil.ReadFile(inspectBlock)
 	logger.Info("Parsing genesis block")
 	block := &cb.Block{}
 	err = proto.Unmarshal(data, block)
 	if err != nil {
-		logger.Fatalf("Error unmarshaling block: %s", err)
+		fmt.Errorf("Error unmarshaling block: %s", err)
 	}
 
 	ctx, err := utils.ExtractEnvelope(block, 0)
 	if err != nil {
-		logger.Fatalf("Error retrieving configtx from block: %s", err)
+		return fmt.Errorf("Error retrieving configtx from block: %s", err)
 	}
 
 	payload, err := utils.UnmarshalPayload(ctx.Payload)
 	if err != nil {
-		logger.Fatalf("Error extracting configtx payload: %s", err)
+		return fmt.Errorf("Error extracting configtx payload: %s", err)
 	}
 
 	if payload.Header == nil {
-		logger.Fatalf("Config block did not contain header")
+		return fmt.Errorf("Config block did not contain header")
 	}
 
 	header, err := utils.UnmarshalChannelHeader(payload.Header.ChannelHeader)
 	if err != nil {
-		logger.Fatalf("Error unmarshaling channel header: %s", err)
+		return fmt.Errorf("Error unmarshaling channel header: %s", err)
 	}
 
 	if header.Type != int32(cb.HeaderType_CONFIG) {
-		logger.Fatalf("Bad header type: %d", header.Type)
+		return fmt.Errorf("Bad header type: %d", header.Type)
 	}
 
 	configEnvelope, err := configtx.UnmarshalConfigEnvelope(payload.Data)
 	if err != nil {
-		logger.Fatalf("Bad configuration envelope")
+		return fmt.Errorf("Bad configuration envelope")
 	}
 
 	if configEnvelope.Config == nil {
-		logger.Fatalf("ConfigEnvelope contained no config")
+		return fmt.Errorf("ConfigEnvelope contained no config")
 	}
 
 	configResult, err := configtx.NewConfigResult(configEnvelope.Config.ChannelGroup, configtx.NewInitializer())
 	if err != nil {
-		logger.Fatalf("Error parsing configuration: %s", err)
+		return fmt.Errorf("Error parsing configuration: %s", err)
 	}
 
 	buffer := &bytes.Buffer{}
@@ -118,16 +120,73 @@ func doInspectBlock(inspectBlock string) {
 	fmt.Printf("Config for channel: %s at sequence %d\n", header.ChannelId, configEnvelope.Config.Sequence)
 
 	fmt.Println(buffer.String())
+	return nil
+}
+
+func doInspectChannelCreateTx(inspectChannelCreateTx string) error {
+	logger.Info("Inspecting transaction")
+	data, err := ioutil.ReadFile(inspectChannelCreateTx)
+	logger.Info("Parsing transaction")
+	env, err := utils.UnmarshalEnvelope(data)
+	if err != nil {
+		return fmt.Errorf("Error unmarshaling envelope: %s", err)
+	}
+
+	payload, err := utils.UnmarshalPayload(env.Payload)
+	if err != nil {
+		return fmt.Errorf("Error extracting configtx payload: %s", err)
+	}
+
+	if payload.Header == nil {
+		return fmt.Errorf("Config block did not contain header")
+	}
+
+	header, err := utils.UnmarshalChannelHeader(payload.Header.ChannelHeader)
+	if err != nil {
+		return fmt.Errorf("Error unmarshaling channel header: %s", err)
+	}
+
+	if header.Type != int32(cb.HeaderType_CONFIG_UPDATE) {
+		return fmt.Errorf("Bad header type: %d", header.Type)
+	}
+
+	configUpdateEnvelope, err := configtx.UnmarshalConfigUpdateEnvelope(payload.Data)
+	if err != nil {
+		return fmt.Errorf("Bad ConfigUpdateEnvelope")
+	}
+
+	configUpdate, err := configtx.UnmarshalConfigUpdate(configUpdateEnvelope.ConfigUpdate)
+	if err != nil {
+		return fmt.Errorf("ConfigUpdateEnvelope contained no config")
+	}
+
+	if configUpdate.ChannelId != header.ChannelId {
+		return fmt.Errorf("ConfigUpdateEnvelope was for different channel than envelope: %s vs %s", configUpdate.ChannelId, header.ChannelId)
+	}
+
+	configResult, err := configtx.NewConfigResult(configUpdate.WriteSet, configtx.NewInitializer())
+	if err != nil {
+		return fmt.Errorf("Error parsing configuration: %s", err)
+	}
+
+	buffer := &bytes.Buffer{}
+	json.Indent(buffer, []byte(configResult.JSON()), "", "    ")
+
+	fmt.Printf("Config for channel: %s\n", header.ChannelId)
+
+	fmt.Println(buffer.String())
+	return nil
 }
 
 func main() {
-	var outputBlock, outputChannelCreateTx, profile, channelID, inspectBlock string
+	var outputBlock, outputChannelCreateTx, profile, channelID, inspectBlock, inspectChannelCreateTx string
 
 	flag.StringVar(&outputBlock, "outputBlock", "", "The path to write the genesis block to (if set)")
 	flag.StringVar(&channelID, "channelID", provisional.TestChainID, "The channel ID to use in the configtx")
 	flag.StringVar(&outputChannelCreateTx, "outputCreateChannelTx", "", "The path to write a channel creation configtx to (if set)")
 	flag.StringVar(&profile, "profile", genesisconfig.SampleInsecureProfile, "The profile from configtx.yaml to use for generation.")
 	flag.StringVar(&inspectBlock, "inspectBlock", "", "Prints the configuration contained in the block at the specified path")
+	flag.StringVar(&inspectChannelCreateTx, "inspectChannelCreateTx", "", "Prints the configuration contained in the transaction at the specified path")
 
 	flag.Parse()
 
@@ -139,15 +198,27 @@ func main() {
 	pgen := provisional.New(config)
 
 	if outputBlock != "" {
-		doOutputBlock(pgen, channelID, outputBlock)
+		if err := doOutputBlock(pgen, channelID, outputBlock); err != nil {
+			logger.Fatalf("Error on outputBlock: %s", err)
+		}
 	}
 
 	if outputChannelCreateTx != "" {
-		doOutputChannelCreateTx(pgen, channelID, outputChannelCreateTx)
+		if err := doOutputChannelCreateTx(pgen, channelID, outputChannelCreateTx); err != nil {
+			logger.Fatalf("Error on outputChannelCreateTx: %s", err)
+		}
 	}
 
 	if inspectBlock != "" {
-		doInspectBlock(inspectBlock)
+		if err := doInspectBlock(inspectBlock); err != nil {
+			logger.Fatalf("Error on inspectBlock: %s", err)
+		}
+	}
+
+	if inspectChannelCreateTx != "" {
+		if err := doInspectChannelCreateTx(inspectChannelCreateTx); err != nil {
+			logger.Fatalf("Error on inspectChannelCreateTx: %s", err)
+		}
 	}
 
 }

common/configtx/tool/configtxgen/main_test.go

@@ -0,0 +1,65 @@
+/*
+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 main
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"github.com/hyperledger/fabric/bccsp/factory"
+	genesisconfig "github.com/hyperledger/fabric/common/configtx/tool/localconfig"
+	"github.com/hyperledger/fabric/common/configtx/tool/provisional"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var tmpDir string
+
+func TestMain(m *testing.M) {
+	dir, err := ioutil.TempDir("", "configtxgen")
+	if err != nil {
+		panic("Error creating temp dir")
+	}
+	tmpDir = dir
+	testResult := m.Run()
+	os.RemoveAll(dir)
+
+	os.Exit(testResult)
+}
+
+func TestInspectBlock(t *testing.T) {
+	blockDest := tmpDir + string(os.PathSeparator) + "block"
+
+	factory.InitFactories(nil)
+	config := genesisconfig.Load(genesisconfig.SampleInsecureProfile)
+	pgen := provisional.New(config)
+
+	assert.NoError(t, doOutputBlock(pgen, "foo", blockDest), "Good block generation request")
+	assert.NoError(t, doInspectBlock(blockDest), "Good block inspection request")
+}
+
+func TestInspectConfigTx(t *testing.T) {
+	configTxDest := tmpDir + string(os.PathSeparator) + "configtx"
+
+	factory.InitFactories(nil)
+	config := genesisconfig.Load(genesisconfig.SampleInsecureProfile)
+	pgen := provisional.New(config)
+
+	assert.NoError(t, doOutputChannelCreateTx(pgen, "foo", configTxDest), "Good outputChannelCreateTx generation request")
+	assert.NoError(t, doInspectChannelCreateTx(configTxDest), "Good configtx inspection request")
+}

docs/configtxgen.md

@@ -39,9 +39,13 @@ configtxgen -profile <profile_name> -outputCreateChannelTx <output.txname>
 
 This will output a marshaled `Envelope` message which may be sent to broadcast to create a channel.
 
-## Reviewing a configuration block
+## Reviewing a configuration
 
-In addition to creating configuration, the `configtxgen` tool is also capable of inspecting configuration.  You may even wish to combine the inspection with generation.  For example:
+In addition to creating configuration, the `configtxgen` tool is also capable of inspecting configuration.
+
+It supports inspecting both configuration blocks, and configuration transactions.  You may use the inspect flags `-inspectBlock` and `-inspectChannelCreateTx` respectively with the path to a file to inspect to output a human readable (JSON) representation of the configuration.
+
+You may even wish to combine the inspection with generation.  For example:
 
 ```
 $ build/bin/configtxgen -channelID foo -outputBlock foo.block -inspectBlock foo.block