[FAB-5836] Cleanup orderer sampleclients

The sample clients for the orderer have fallen into a mild state of
disrepair.

The single_tx_client has not worked in a long time, and some unnecessary
sleeps have crept into broadcast_msg.  Additionally, deliver_stdout does
not sign messages properly, and tries to print binary to the screen.

This CR fixes all of those issues.

Change-Id: Iec182163fcbc06197d6bd944e3b4f2e58a0de769
Signed-off-by: Jason Yellick <jyellick@us.ibm.com>

Author: Jason Yellick

orderer/sample_clients/broadcast_msg/client.go

@@ -11,7 +11,6 @@ import (
 	"fmt"
 	"os"
 	"sync"
-	"time"
 
 	"github.com/hyperledger/fabric/common/crypto"
 	"github.com/hyperledger/fabric/common/localmsp"
@@ -27,22 +26,21 @@ import (
 )
 
 type broadcastClient struct {
-	client  ab.AtomicBroadcast_BroadcastClient
-	signer  crypto.LocalSigner
-	chainID string
+	client    ab.AtomicBroadcast_BroadcastClient
+	signer    crypto.LocalSigner
+	channelID string
 }
 
 // newBroadcastClient creates a simple instance of the broadcastClient interface
-func newBroadcastClient(client ab.AtomicBroadcast_BroadcastClient, chainID string, signer crypto.LocalSigner) *broadcastClient {
-	return &broadcastClient{client: client, chainID: chainID, signer: signer}
+func newBroadcastClient(client ab.AtomicBroadcast_BroadcastClient, channelID string, signer crypto.LocalSigner) *broadcastClient {
+	return &broadcastClient{client: client, channelID: channelID, signer: signer}
 }
 
 func (s *broadcastClient) broadcast(transaction []byte) error {
-	env, err := utils.CreateSignedEnvelope(cb.HeaderType_MESSAGE, s.chainID, s.signer, &cb.Envelope{Signature: transaction}, 0, 0)
+	env, err := utils.CreateSignedEnvelope(cb.HeaderType_MESSAGE, s.channelID, s.signer, &cb.ConfigValue{Value: transaction}, 0, 0)
 	if err != nil {
 		panic(err)
 	}
-	time.Sleep(time.Second)
 	return s.client.Send(env)
 }
 
@@ -69,14 +67,14 @@ func main() {
 
 	signer := localmsp.NewSigner()
 
-	var chainID string
+	var channelID string
 	var serverAddr string
 	var messages uint64
 	var goroutines uint64
 	var msgSize uint64
 
 	flag.StringVar(&serverAddr, "server", fmt.Sprintf("%s:%d", config.General.ListenAddress, config.General.ListenPort), "The RPC server to connect to.")
-	flag.StringVar(&chainID, "chainID", provisional.TestChainID, "The chain ID to broadcast to.")
+	flag.StringVar(&channelID, "channelID", provisional.TestChainID, "The channel ID to broadcast to.")
 	flag.Uint64Var(&messages, "messages", 1, "The number of messages to broadcast.")
 	flag.Uint64Var(&goroutines, "goroutines", 1, "The number of concurrent go routines to broadcast the messages on")
 	flag.Uint64Var(&msgSize, "size", 1024, "The size in bytes of the data section for the payload")
@@ -104,13 +102,12 @@ func main() {
 	for i := uint64(0); i < goroutines; i++ {
 		go func(i uint64) {
 			client, err := ab.NewAtomicBroadcastClient(conn).Broadcast(context.TODO())
-			time.Sleep(10 * time.Second)
 			if err != nil {
 				fmt.Println("Error connecting:", err)
 				return
 			}
 
-			s := newBroadcastClient(client, chainID, signer)
+			s := newBroadcastClient(client, channelID, signer)
 			done := make(chan (struct{}))
 			go func() {
 				for i := uint64(0); i < msgsPerGo; i++ {

orderer/sample_clients/deliver_stdout/client.go

@@ -1,17 +1,7 @@
 /*
-Copyright IBM Corp. 2016 All Rights Reserved.
+Copyright IBM Corp. 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.
+SPDX-License-Identifier: Apache-2.0
 */
 
 package main
@@ -20,12 +10,18 @@ import (
 	"flag"
 	"fmt"
 	"math"
+	"os"
 
+	"github.com/hyperledger/fabric/common/crypto"
+	"github.com/hyperledger/fabric/common/localmsp"
 	"github.com/hyperledger/fabric/common/tools/configtxgen/provisional"
+	"github.com/hyperledger/fabric/common/tools/protolator"
+	mspmgmt "github.com/hyperledger/fabric/msp/mgmt"
 	"github.com/hyperledger/fabric/orderer/common/localconfig"
 	cb "github.com/hyperledger/fabric/protos/common"
 	ab "github.com/hyperledger/fabric/protos/orderer"
 	"github.com/hyperledger/fabric/protos/utils"
+
 	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 )
@@ -37,44 +33,39 @@ var (
 )
 
 type deliverClient struct {
-	client  ab.AtomicBroadcast_DeliverClient
-	chainID string
+	client    ab.AtomicBroadcast_DeliverClient
+	channelID string
+	signer    crypto.LocalSigner
+	quiet     bool
 }
 
-func newDeliverClient(client ab.AtomicBroadcast_DeliverClient, chainID string) *deliverClient {
-	return &deliverClient{client: client, chainID: chainID}
+func newDeliverClient(client ab.AtomicBroadcast_DeliverClient, channelID string, signer crypto.LocalSigner, quiet bool) *deliverClient {
+	return &deliverClient{client: client, channelID: channelID, signer: signer, quiet: quiet}
 }
 
-func seekHelper(chainID string, start *ab.SeekPosition, stop *ab.SeekPosition) *cb.Envelope {
-	return &cb.Envelope{
-		Payload: utils.MarshalOrPanic(&cb.Payload{
-			Header: &cb.Header{
-				ChannelHeader: utils.MarshalOrPanic(&cb.ChannelHeader{
-					ChannelId: chainID,
-				}),
-				SignatureHeader: utils.MarshalOrPanic(&cb.SignatureHeader{}),
-			},
-
-			Data: utils.MarshalOrPanic(&ab.SeekInfo{
-				Start:    start,
-				Stop:     stop,
-				Behavior: ab.SeekInfo_BLOCK_UNTIL_READY,
-			}),
-		}),
+func (r *deliverClient) seekHelper(start *ab.SeekPosition, stop *ab.SeekPosition) *cb.Envelope {
+	env, err := utils.CreateSignedEnvelope(cb.HeaderType_DELIVER_SEEK_INFO, r.channelID, r.signer, &ab.SeekInfo{
+		Start:    start,
+		Stop:     stop,
+		Behavior: ab.SeekInfo_BLOCK_UNTIL_READY,
+	}, 0, 0)
+	if err != nil {
+		panic(err)
 	}
+	return env
 }
 
 func (r *deliverClient) seekOldest() error {
-	return r.client.Send(seekHelper(r.chainID, oldest, maxStop))
+	return r.client.Send(r.seekHelper(oldest, maxStop))
 }
 
 func (r *deliverClient) seekNewest() error {
-	return r.client.Send(seekHelper(r.chainID, newest, maxStop))
+	return r.client.Send(r.seekHelper(newest, maxStop))
 }
 
 func (r *deliverClient) seekSingle(blockNumber uint64) error {
 	specific := &ab.SeekPosition{Type: &ab.SeekPosition_Specified{Specified: &ab.SeekSpecified{Number: blockNumber}}}
-	return r.client.Send(seekHelper(r.chainID, specific, specific))
+	return r.client.Send(r.seekHelper(specific, specific))
 }
 
 func (r *deliverClient) readUntilClose() {
@@ -90,20 +81,39 @@ func (r *deliverClient) readUntilClose() {
 			fmt.Println("Got status ", t)
 			return
 		case *ab.DeliverResponse_Block:
-			fmt.Println("Received block: ", t.Block)
+			if !r.quiet {
+				fmt.Println("Received block: ")
+				err := protolator.DeepMarshalJSON(os.Stdout, t.Block)
+				if err != nil {
+					fmt.Println("  Error pretty printing block: %s", err)
+				}
+			} else {
+				fmt.Println("Received block: ", t.Block.Header.Number)
+			}
 		}
 	}
 }
 
 func main() {
 	config := config.Load()
 
-	var chainID string
+	// Load local MSP
+	err := mspmgmt.LoadLocalMsp(config.General.LocalMSPDir, config.General.BCCSP, config.General.LocalMSPID)
+	if err != nil { // Handle errors reading the config file
+		fmt.Println("Failed to initialize local MSP:", err)
+		os.Exit(0)
+	}
+
+	signer := localmsp.NewSigner()
+
+	var channelID string
 	var serverAddr string
 	var seek int
+	var quiet bool
 
 	flag.StringVar(&serverAddr, "server", fmt.Sprintf("%s:%d", config.General.ListenAddress, config.General.ListenPort), "The RPC server to connect to.")
-	flag.StringVar(&chainID, "chainID", provisional.TestChainID, "The chain ID to deliver from.")
+	flag.StringVar(&channelID, "channelID", provisional.TestChainID, "The channel ID to deliver from.")
+	flag.BoolVar(&quiet, "quiet", false, "Only print the block number, will not attempt to print its block contents.")
 	flag.IntVar(&seek, "seek", -2, "Specify the range of requested blocks."+
 		"Acceptable values:"+
 		"-2 (or -1) to start from oldest (or newest) and keep at it indefinitely."+
@@ -126,7 +136,7 @@ func main() {
 		return
 	}
 
-	s := newDeliverClient(client, chainID)
+	s := newDeliverClient(client, channelID, signer, quiet)
 	switch seek {
 	case -2:
 		err = s.seekOldest()

orderer/sample_clients/single_tx_client/single_tx_client.go

@@ -30,6 +30,7 @@ func (p *Payload) VariablyOpaqueFields() []string {
 var PayloadDataMap = map[int32]proto.Message{
 	int32(HeaderType_CONFIG):        &ConfigEnvelope{},
 	int32(HeaderType_CONFIG_UPDATE): &ConfigUpdateEnvelope{},
+	int32(HeaderType_MESSAGE):       &ConfigValue{}, // Only used by broadcast_msg sample client
 }
 
 func (p *Payload) VariablyOpaqueFieldProto(name string) (proto.Message, error) {