Revert [FAB-6230] pCLI support for cfg lifecycle

This reverts commit 2263248a220b2fb9762c3b28e8572ffb9a23927a.

Change-Id: I0feb9d3c1ac6a8d89fb2da4b3f2e568ae26fa55a
Signed-off-by: yacovm <yacovm@il.ibm.com>

Author: yacovm

peer/chaincode/chaincode.go

@@ -50,26 +50,24 @@ func Cmd(cf *ChaincodeCmdFactory) *cobra.Command {
 
 // Chaincode-related variables.
 var (
-	chaincodeLang            string
-	chaincodeCtorJSON        string
-	chaincodePath            string
-	chaincodeName            string
-	chaincodeUsr             string // Not used
-	chaincodeQueryRaw        bool
-	chaincodeQueryHex        bool
-	customIDGenAlg           string
-	channelID                string
-	chaincodeVersion         string
-	policy                   string
-	escc                     string
-	vscc                     string
-	policyMarshalled         []byte
-	orderingEndpoint         string
-	tls                      bool
-	caFile                   string
-	transient                string
-	resourceEnvelopeSavePath string
-	resourceEnvelopeLoadPath string
+	chaincodeLang     string
+	chaincodeCtorJSON string
+	chaincodePath     string
+	chaincodeName     string
+	chaincodeUsr      string // Not used
+	chaincodeQueryRaw bool
+	chaincodeQueryHex bool
+	customIDGenAlg    string
+	channelID         string
+	chaincodeVersion  string
+	policy            string
+	escc              string
+	vscc              string
+	policyMarshalled  []byte
+	orderingEndpoint  string
+	tls               bool
+	caFile            string
+	transient         string
 )
 
 var chaincodeCmd = &cobra.Command{
@@ -110,10 +108,6 @@ func resetFlags() {
 		fmt.Sprint("The name of the endorsement system chaincode to be used for this chaincode"))
 	flags.StringVarP(&vscc, "vscc", "V", common.UndefinedParamValue,
 		fmt.Sprint("The name of the verification system chaincode to be used for this chaincode"))
-	flags.StringVarP(&resourceEnvelopeSavePath, "resourceEnvelopeSavePath", "S", common.UndefinedParamValue,
-		fmt.Sprint("Specifies the file to save the resource config update to. If not specified, sends config update"))
-	flags.StringVarP(&resourceEnvelopeLoadPath, "resourceEnvelopeLoadPath", "L", common.UndefinedParamValue,
-		fmt.Sprint("Specifies the file to load the resource config update from. If not specified, creates a new config update"))
 	flags.BoolVarP(&getInstalledChaincodes, "installed", "", false,
 		"Get the installed chaincodes on a peer")
 	flags.BoolVarP(&getInstantiatedChaincodes, "instantiated", "", false,
@@ -126,7 +120,7 @@ func attachFlags(cmd *cobra.Command, names []string) {
 		if flag := flags.Lookup(name); flag != nil {
 			cmdFlags.AddFlag(flag)
 		} else {
-			logger.Fatalf("Could not find flag '%s' to attach to command '%s'", name, cmd.Name())
+			logger.Fatalf("Could not find flag '%s' to attach to commond '%s'", name, cmd.Name())
 		}
 	}
 }

peer/chaincode/instantiate.go

@@ -17,12 +17,12 @@ limitations under the License.
 package chaincode
 
 import (
+	"errors"
 	"fmt"
 
-	"github.com/hyperledger/fabric/protos/common"
+	protcommon "github.com/hyperledger/fabric/protos/common"
 	pb "github.com/hyperledger/fabric/protos/peer"
 	"github.com/hyperledger/fabric/protos/utils"
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"golang.org/x/net/context"
 )
@@ -41,17 +41,7 @@ func instantiateCmd(cf *ChaincodeCmdFactory) *cobra.Command {
 		Long:      fmt.Sprint(instantiateDesc),
 		ValidArgs: []string{"1"},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			cf1 := cf
-			if cf1 == nil {
-				var err error
-				cf1, err = InitCmdFactory(true, true)
-				if err != nil {
-					return err
-				}
-			}
-			return chaincodeDeploy(cf1, func() error {
-				return lsccInstantiate(cmd, cf1)
-			})
+			return chaincodeDeploy(cmd, args, cf)
 		},
 	}
 	flagList := []string{
@@ -63,15 +53,14 @@ func instantiateCmd(cf *ChaincodeCmdFactory) *cobra.Command {
 		"policy",
 		"escc",
 		"vscc",
-		"resourceEnvelopeSavePath",
-		"resourceEnvelopeLoadPath",
 	}
 	attachFlags(chaincodeInstantiateCmd, flagList)
+
 	return chaincodeInstantiateCmd
 }
 
 //instantiate the command via Endorser
-func instantiate(cmd *cobra.Command, cf *ChaincodeCmdFactory) (*common.Envelope, error) {
+func instantiate(cmd *cobra.Command, cf *ChaincodeCmdFactory) (*protcommon.Envelope, error) {
 	spec, err := getChaincodeSpec(cmd)
 	if err != nil {
 		return nil, err
@@ -119,29 +108,26 @@ func instantiate(cmd *cobra.Command, cf *ChaincodeCmdFactory) (*common.Envelope,
 // chaincodeDeploy instantiates the chaincode. On success, the chaincode name
 // (hash) is printed to STDOUT for use by subsequent chaincode-related CLI
 // commands.
-func chaincodeDeploy(cf *ChaincodeCmdFactory, sendInit sendInitTransaction) error {
+func chaincodeDeploy(cmd *cobra.Command, args []string, cf *ChaincodeCmdFactory) error {
 	if channelID == "" {
 		return errors.New("The required parameter 'channelID' is empty. Rerun the command with -C flag")
 	}
 	var err error
-
-	defer cf.BroadcastClient.Close()
-
-	ss := &sigSupport{cf.Signer}
-	version, config, err := fetchResourceConfig(cf.EndorserClient, ss, channelID)
-	if err != nil {
-		return errors.Wrap(err, "failed probing channel version")
-	}
-	if version == v11 {
-		return configBasedLifecycleUpdate(ss, cf, config, sendInit)
+	if cf == nil {
+		cf, err = InitCmdFactory(true, true)
+		if err != nil {
+			return err
+		}
 	}
-	return sendInit()
-}
-
-func lsccInstantiate(cmd *cobra.Command, cf *ChaincodeCmdFactory) error {
+	defer cf.BroadcastClient.Close()
 	env, err := instantiate(cmd, cf)
 	if err != nil {
 		return err
 	}
-	return cf.BroadcastClient.Send(env)
+
+	if env != nil {
+		err = cf.BroadcastClient.Send(env)
+	}
+
+	return err
 }

peer/chaincode/instantiate_test.go

@@ -17,27 +17,16 @@
 package chaincode
 
 import (
-	"errors"
 	"testing"
 
-	"github.com/hyperledger/fabric/peer/common"
-	"github.com/hyperledger/fabric/protos/peer"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestInstantiateCmd(t *testing.T) {
 	InitMSP()
 
-	newMockCF := func() *ChaincodeCmdFactory {
-		mockCF, err := getMockChaincodeCmdFactoryWithEnorserResponses(common.MockResponse{Error: errors.New("chaincode error")}, common.MockResponse{
-			Response: &peer.ProposalResponse{
-				Response:    &peer.Response{Status: 200},
-				Endorsement: &peer.Endorsement{},
-			},
-		})
-		assert.NoError(t, err, "Error getting mock chaincode command factory")
-		return mockCF
-	}
+	mockCF, err := getMockChaincodeCmdFactory()
+	assert.NoError(t, err, "Error getting mock chaincode command factory")
 
 	// basic function tests
 	var tests = []struct {
@@ -86,10 +75,10 @@ func TestInstantiateCmd(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			resetFlags()
-			cmd := instantiateCmd(newMockCF())
+			cmd := instantiateCmd(mockCF)
 			addFlags(cmd)
 			cmd.SetArgs(test.args)
-			err := cmd.Execute()
+			err = cmd.Execute()
 			checkError(t, err, test.errorExpected, test.errMsg)
 		})
 	}

peer/chaincode/invoke_test.go

@@ -179,31 +179,38 @@ func TestInvokeCmdEndorsementFailure(t *testing.T) {
 
 // Returns mock chaincode command factory
 func getMockChaincodeCmdFactory() (*ChaincodeCmdFactory, error) {
-	return getMockChaincodeCmdFactoryWithEnorserResponses(common.MockResponse{
-		Response: &pb.ProposalResponse{
-			Response:    &pb.Response{Status: 200},
-			Endorsement: &pb.Endorsement{},
-		},
-	})
+	signer, err := common.GetDefaultSigner()
+	if err != nil {
+		return nil, err
+	}
+	mockResponse := &pb.ProposalResponse{
+		Response:    &pb.Response{Status: 200},
+		Endorsement: &pb.Endorsement{},
+	}
+	mockEndorserClient := common.GetMockEndorserClient(mockResponse, nil)
+	mockBroadcastClient := common.GetMockBroadcastClient(nil)
+	mockCF := &ChaincodeCmdFactory{
+		EndorserClient:  mockEndorserClient,
+		Signer:          signer,
+		BroadcastClient: mockBroadcastClient,
+	}
+	return mockCF, nil
 }
 
 // Returns mock chaincode command factory that is constructed with an endorser
 // client that returns an error for proposal request
 func getMockChaincodeCmdFactoryWithErr() (*ChaincodeCmdFactory, error) {
-	return getMockChaincodeCmdFactoryWithEnorserResponses(common.MockResponse{
-		Error: errors.New("invoke error"),
-	})
-}
-
-func getMockChaincodeCmdFactoryWithEnorserResponses(responses ...common.MockResponse) (*ChaincodeCmdFactory, error) {
 	signer, err := common.GetDefaultSigner()
 	if err != nil {
 		return nil, err
 	}
-	mockEndorserClient := common.GetMockMultiEndorserClient(responses...)
+
+	errMsg := "invoke error"
+	mockEndorerClient := common.GetMockEndorserClient(nil, errors.New(errMsg))
 	mockBroadcastClient := common.GetMockBroadcastClient(nil)
+
 	mockCF := &ChaincodeCmdFactory{
-		EndorserClient:  mockEndorserClient,
+		EndorserClient:  mockEndorerClient,
 		Signer:          signer,
 		BroadcastClient: mockBroadcastClient,
 	}

peer/chaincode/resources.go

@@ -9,19 +9,14 @@ package chaincode
 import (
 	"bytes"
 	"fmt"
-	"io/ioutil"
-	"os"
 	"strings"
 	"time"
 
 	"github.com/golang/protobuf/proto"
-	"github.com/hyperledger/fabric/common/cauthdsl"
 	"github.com/hyperledger/fabric/common/resourcesconfig"
-	update2 "github.com/hyperledger/fabric/common/tools/configtxlator/update"
 	"github.com/hyperledger/fabric/common/util"
 	"github.com/hyperledger/fabric/core/chaincode/shim"
 	"github.com/hyperledger/fabric/core/scc/lscc"
-	"github.com/hyperledger/fabric/msp"
 	"github.com/hyperledger/fabric/protos/common"
 	"github.com/hyperledger/fabric/protos/peer"
 	"github.com/hyperledger/fabric/protos/utils"
@@ -344,105 +339,3 @@ func getModPolicies(ccGrp *common.ConfigGroup, update ccUpdate) map[string]strin
 	}
 	return modPolicies
 }
-
-func configBasedLifecycleUpdate(ss *sigSupport, cf *ChaincodeCmdFactory, config *common.Config, sendInit sendInitTransaction) error {
-	var env *common.Envelope
-	hash, err := fetchCCID(ss, cf.EndorserClient, chaincodeName, chaincodeVersion)
-	if err != nil {
-		return err
-	}
-	var pol *common.SignaturePolicyEnvelope
-	if policy != "" {
-		pol, err = cauthdsl.FromString(policy)
-		if err != nil {
-			return err
-		}
-	}
-
-	if policy == "" && (vscc == "vscc" || vscc == "") {
-		return errors.New("policy must be specified when vscc flag is set to 'vscc' or missing")
-	}
-
-	update := ccUpdate{
-		policy:           pol,
-		computeDelta:     update2.Compute,
-		ccName:           chaincodeName,
-		oldConfig:        config,
-		version:          chaincodeVersion,
-		endorsement:      escc,
-		validation:       vscc,
-		hash:             hash,
-		chainID:          channelID,
-		SignatureSupport: &sigSupport{cf.Signer},
-	}
-	if resourceEnvelopeLoadPath == "" {
-		// We're making a new config update
-		env = update.buildCCUpdateEnvelope()
-	} else {
-		// We're loading the config update from disk
-		updateEnv, err := loadEnvelope(resourceEnvelopeLoadPath)
-		if err != nil {
-			return err
-		}
-		// and appending our signature to it
-		updateEnv = update.appendSignature(updateEnv)
-		// and putting it back into an envelope
-		env = update.updateIntoEnvelope(updateEnv)
-	}
-	if resourceEnvelopeSavePath != "" {
-		return saveEnvelope(env)
-	}
-	if err := cf.BroadcastClient.Send(env); err != nil {
-		return err
-	}
-	return sendInit()
-}
-
-func loadEnvelope(file string) (*common.ConfigUpdateEnvelope, error) {
-	data, err := ioutil.ReadFile(file)
-	if err != nil {
-		return nil, err
-	}
-	env := &common.Envelope{}
-	if err := proto.Unmarshal(data, env); err != nil {
-		return nil, err
-	}
-	payload := &common.Payload{}
-	if err := proto.Unmarshal(env.Payload, payload); err != nil {
-		return nil, err
-	}
-	update := &common.ConfigUpdateEnvelope{}
-	if err := proto.Unmarshal(payload.Data, update); err != nil {
-		return nil, err
-	}
-	return update, nil
-}
-
-func saveEnvelope(env *common.Envelope) error {
-	f, err := os.Create(resourceEnvelopeSavePath)
-	if err != nil {
-		return errors.Errorf("failed saving resource envelope to file %s: %v", resourceEnvelopeSavePath, err)
-	}
-	if _, err := f.Write(utils.MarshalOrPanic(env)); err != nil {
-		return errors.Errorf("failed saving resource envelope to file %s: %v", resourceEnvelopeSavePath, err)
-	}
-	fmt.Printf(`Saved config update envelope to %s.
-			You can now either:
-			1) Append your signature using --resourceEnvelopeSave along with --resourceEnvelopeLoad
-			2) Submit a transaction using only --resourceEnvelopeLoad
-			`, f.Name())
-	return nil
-}
-
-type sigSupport struct {
-	msp.SigningIdentity
-}
-
-// NewSignatureHeader creates a new signature header
-func (s *sigSupport) NewSignatureHeader() (*common.SignatureHeader, error) {
-	sID, err := s.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	return utils.MakeSignatureHeader(sID, utils.CreateNonceOrPanic()), nil
-}