[FAB-5889] Update peer CLI code to new errors pkg

This CR updates the peer CLI code that used the error handling
framework located at fabric/common/errors to use the newly vendored
github.com/pkg/errors package. It also updates fmt.Errorf() calls
in the package.

Change-Id: I1c4668fd9f8d58076761f7f20d0561a9bcd3ef1b
Signed-off-by: Will Lahti <wtlahti@us.ibm.com>

Author: wlahti

peer/channel/join_test.go

@@ -156,5 +156,5 @@ func TestJoinNilCF(t *testing.T) {
 
 	err = cmd.Execute()
 	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "Error trying to connect to local peer")
+	assert.Contains(t, err.Error(), "error trying to connect to local peer")
 }

peer/clilogging/common.go

@@ -17,10 +17,10 @@ limitations under the License.
 package clilogging
 
 import (
-	"github.com/hyperledger/fabric/common/errors"
 	"github.com/hyperledger/fabric/peer/common"
 	pb "github.com/hyperledger/fabric/protos/peer"
 
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 )
 
@@ -48,21 +48,21 @@ func checkLoggingCmdParams(cmd *cobra.Command, args []string) error {
 	var err error
 	if cmd.Name() == "revertlevels" {
 		if len(args) > 0 {
-			err = errors.ErrorWithCallstack("LOG", "400", "More parameters than necessary were provided. Expected 0, received %d.", len(args))
+			err = errors.Errorf("more parameters than necessary were provided. Expected 0, received %d", len(args))
 			return err
 		}
 	} else {
 		// check that at least one parameter is passed in
 		if len(args) == 0 {
-			err = errors.ErrorWithCallstack("LOG", "400", "No parameters provided.")
+			err = errors.New("no parameters provided")
 			return err
 		}
 	}
 
 	if cmd.Name() == "setlevel" {
 		// check that log level parameter is provided
 		if len(args) == 1 {
-			err = errors.ErrorWithCallstack("LOG", "400", "No log level provided.")
+			err = errors.New("no log level provided")
 		} else {
 			// check that log level is valid. if not, err is set
 			err = common.CheckLogLevel(args[1])

peer/common/common.go

@@ -22,7 +22,6 @@ import (
 
 	"github.com/hyperledger/fabric/bccsp/factory"
 	"github.com/hyperledger/fabric/common/channelconfig"
-	"github.com/hyperledger/fabric/common/errors"
 	"github.com/hyperledger/fabric/common/flogging"
 	"github.com/hyperledger/fabric/common/viperutil"
 	"github.com/hyperledger/fabric/core/config"
@@ -34,6 +33,7 @@ import (
 	pb "github.com/hyperledger/fabric/protos/peer"
 	putils "github.com/hyperledger/fabric/protos/utils"
 	"github.com/op/go-logging"
+	"github.com/pkg/errors"
 	"github.com/spf13/viper"
 	"golang.org/x/net/context"
 )
@@ -77,7 +77,7 @@ func InitConfig(cmdRoot string) error {
 
 	err := viper.ReadInConfig() // Find and read the config file
 	if err != nil {             // Handle errors reading the config file
-		return fmt.Errorf("Error when reading %s config file: %s", cmdRoot, err)
+		return errors.WithMessage(err, fmt.Sprintf("error when reading %s config file", cmdRoot))
 	}
 
 	return nil
@@ -90,19 +90,19 @@ func InitCrypto(mspMgrConfigDir string, localMSPID string) error {
 	_, err = os.Stat(mspMgrConfigDir)
 	if os.IsNotExist(err) {
 		// No need to try to load MSP from folder which is not available
-		return fmt.Errorf("cannot init crypto, missing %s folder", mspMgrConfigDir)
+		return errors.Errorf("cannot init crypto, missing %s folder", mspMgrConfigDir)
 	}
 
 	// Init the BCCSP
 	var bccspConfig *factory.FactoryOpts
 	err = viperutil.EnhancedExactUnmarshalKey("peer.BCCSP", &bccspConfig)
 	if err != nil {
-		return fmt.Errorf("could not parse YAML config [%s]", err)
+		return errors.WithMessage(err, "could not parse YAML config")
 	}
 
 	err = mspmgmt.LoadLocalMsp(mspMgrConfigDir, bccspConfig, localMSPID)
 	if err != nil {
-		return fmt.Errorf("error when setting up MSP from directory %s: err %s", mspMgrConfigDir, err)
+		return errors.WithMessage(err, fmt.Sprintf("error when setting up MSP from directory %s", mspMgrConfigDir))
 	}
 
 	return nil
@@ -112,8 +112,7 @@ func InitCrypto(mspMgrConfigDir string, localMSPID string) error {
 func GetEndorserClient() (pb.EndorserClient, error) {
 	clientConn, err := peer.NewPeerClientConnection()
 	if err != nil {
-		err = errors.ErrorWithCallstack("PER", "404", "Error trying to connect to local peer").WrapError(err)
-		return nil, err
+		return nil, errors.WithMessage(err, "error trying to connect to local peer")
 	}
 	endorserClient := pb.NewEndorserClient(clientConn)
 	return endorserClient, nil
@@ -123,8 +122,7 @@ func GetEndorserClient() (pb.EndorserClient, error) {
 func GetAdminClient() (pb.AdminClient, error) {
 	clientConn, err := peer.NewPeerClientConnection()
 	if err != nil {
-		err = errors.ErrorWithCallstack("PER", "404", "Error trying to connect to local peer").WrapError(err)
-		return nil, err
+		return nil, errors.WithMessage(err, "error trying to connect to local peer")
 	}
 	adminClient := pb.NewAdminClient(clientConn)
 	return adminClient, nil
@@ -134,7 +132,7 @@ func GetAdminClient() (pb.AdminClient, error) {
 func GetDefaultSigner() (msp.SigningIdentity, error) {
 	signer, err := mspmgmt.GetLocalMSP().GetDefaultSigningIdentity()
 	if err != nil {
-		return nil, fmt.Errorf("Error obtaining the default signing identity, err %s", err)
+		return nil, errors.WithMessage(err, "error obtaining the default signing identity")
 	}
 
 	return signer, err
@@ -154,45 +152,45 @@ func GetOrdererEndpointOfChain(chainID string, signer msp.SigningIdentity, endor
 
 	creator, err := signer.Serialize()
 	if err != nil {
-		return nil, fmt.Errorf("Error serializing identity for %s: %s", signer.GetIdentifier(), err)
+		return nil, errors.WithMessage(err, fmt.Sprintf("error serializing identity for %s", signer.GetIdentifier()))
 	}
 
 	prop, _, err := putils.CreateProposalFromCIS(pcommon.HeaderType_CONFIG, "", invocation, creator)
 	if err != nil {
-		return nil, fmt.Errorf("Error creating GetConfigBlock proposal: %s", err)
+		return nil, errors.WithMessage(err, "error creating GetConfigBlock proposal")
 	}
 
 	signedProp, err := putils.GetSignedProposal(prop, signer)
 	if err != nil {
-		return nil, fmt.Errorf("Error creating signed GetConfigBlock proposal: %s", err)
+		return nil, errors.WithMessage(err, "error creating signed GetConfigBlock proposal")
 	}
 
 	proposalResp, err := endorserClient.ProcessProposal(context.Background(), signedProp)
 	if err != nil {
-		return nil, fmt.Errorf("Error endorsing GetConfigBlock: %s", err)
+		return nil, errors.WithMessage(err, "error endorsing GetConfigBlock")
 	}
 
 	if proposalResp == nil {
-		return nil, fmt.Errorf("Error nil proposal response: %s", err)
+		return nil, errors.WithMessage(err, "error nil proposal response")
 	}
 
 	if proposalResp.Response.Status != 0 && proposalResp.Response.Status != 200 {
-		return nil, fmt.Errorf("Error bad proposal response %d", proposalResp.Response.Status)
+		return nil, errors.Errorf("error bad proposal response %d", proposalResp.Response.Status)
 	}
 
 	// parse config block
 	block, err := putils.GetBlockFromBlockBytes(proposalResp.Response.Payload)
 	if err != nil {
-		return nil, fmt.Errorf("Error unmarshaling config block: %s", err)
+		return nil, errors.WithMessage(err, "error unmarshaling config block")
 	}
 
 	envelopeConfig, err := putils.ExtractEnvelope(block, 0)
 	if err != nil {
-		return nil, fmt.Errorf("Error extracting config block envelope: %s", err)
+		return nil, errors.WithMessage(err, "error extracting config block envelope")
 	}
 	bundle, err := channelconfig.NewBundleFromEnvelope(envelopeConfig)
 	if err != nil {
-		return nil, fmt.Errorf("Error loadding config block: %s", err)
+		return nil, errors.WithMessage(err, "error loading config block")
 	}
 
 	return bundle.ChannelConfig().OrdererAddresses(), nil
@@ -203,7 +201,7 @@ func GetOrdererEndpointOfChain(chainID string, signer msp.SigningIdentity, endor
 func SetLogLevelFromViper(module string) error {
 	var err error
 	if module == "" {
-		return fmt.Errorf("log level not set, no module name provided")
+		return errors.New("log level not set, no module name provided")
 	}
 	logLevelFromViper := viper.GetString("logging." + module)
 	err = CheckLogLevel(logLevelFromViper)
@@ -218,7 +216,7 @@ func SetLogLevelFromViper(module string) error {
 func CheckLogLevel(level string) error {
 	_, err := logging.LogLevel(level)
 	if err != nil {
-		err = errors.ErrorWithCallstack("LOG", "400", "Invalid log level provided - %s", level)
+		err = errors.Errorf("invalid log level provided - %s", level)
 	}
 	return err
 }

peer/common/ordererclient.go

@@ -23,6 +23,7 @@ import (
 
 	cb "github.com/hyperledger/fabric/protos/common"
 	ab "github.com/hyperledger/fabric/protos/orderer"
+	"github.com/pkg/errors"
 	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
@@ -43,7 +44,7 @@ type broadcastClient struct {
 func GetBroadcastClient(orderingEndpoint string, tlsEnabled bool, caFile string) (BroadcastClient, error) {
 
 	if len(strings.Split(orderingEndpoint, ":")) != 2 {
-		return nil, fmt.Errorf("Ordering service endpoint %s is not valid or missing", orderingEndpoint)
+		return nil, errors.Errorf("ordering service endpoint %s is not valid or missing", orderingEndpoint)
 	}
 
 	var opts []grpc.DialOption
@@ -52,7 +53,7 @@ func GetBroadcastClient(orderingEndpoint string, tlsEnabled bool, caFile string)
 		if caFile != "" {
 			creds, err := credentials.NewClientTLSFromFile(caFile, "")
 			if err != nil {
-				return nil, fmt.Errorf("Error connecting to %s due to %s", orderingEndpoint, err)
+				return nil, errors.WithMessage(err, fmt.Sprintf("error connecting to %s due to", orderingEndpoint))
 			}
 			opts = append(opts, grpc.WithTransportCredentials(creds))
 		}
@@ -65,12 +66,12 @@ func GetBroadcastClient(orderingEndpoint string, tlsEnabled bool, caFile string)
 
 	conn, err := grpc.Dial(orderingEndpoint, opts...)
 	if err != nil {
-		return nil, fmt.Errorf("Error connecting to %s due to %s", orderingEndpoint, err)
+		return nil, errors.WithMessage(err, fmt.Sprintf("error connecting to %s due to", orderingEndpoint))
 	}
 	client, err := ab.NewAtomicBroadcastClient(conn).Broadcast(context.TODO())
 	if err != nil {
 		conn.Close()
-		return nil, fmt.Errorf("Error connecting to %s due to %s", orderingEndpoint, err)
+		return nil, errors.WithMessage(err, fmt.Sprintf("error connecting to %s due to", orderingEndpoint))
 	}
 
 	return &broadcastClient{conn: conn, client: client}, nil
@@ -82,15 +83,15 @@ func (s *broadcastClient) getAck() error {
 		return err
 	}
 	if msg.Status != cb.Status_SUCCESS {
-		return fmt.Errorf("Got unexpected status: %v -- %s", msg.Status, msg.Info)
+		return errors.Errorf("got unexpected status: %v -- %s", msg.Status, msg.Info)
 	}
 	return nil
 }
 
 //Send data to orderer
 func (s *broadcastClient) Send(env *cb.Envelope) error {
 	if err := s.client.Send(env); err != nil {
-		return fmt.Errorf("Could not send :%s)", err)
+		return errors.WithMessage(err, "could not send")
 	}
 
 	err := s.getAck()