FAB-11520 Add implementation for ChaincodeInstall

This CR provides a basic implementation of a new ChaincodeInstall to be
utilized by the new lifecycle SCC in a future CR.

Makes #Done FAB-11520

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

Author: Jason Yellick

core/chaincode/lifecycle/lifecycle.go

@@ -0,0 +1,46 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package lifecycle
+
+import (
+	"github.com/hyperledger/fabric/core/chaincode/persistence"
+
+	"github.com/pkg/errors"
+)
+
+// ChaincodeStore provides a way to persist chaincodes
+type ChaincodeStore interface {
+	Save(name, version string, ccInstallPkg []byte) (hash []byte, err error)
+}
+
+type PackageParser interface {
+	Parse(data []byte) (*persistence.ChaincodePackage, error)
+}
+
+// Lifecycle implements the lifecycle operations which are invoked
+// by the SCC as well as internally
+type Lifecycle struct {
+	ChaincodeStore ChaincodeStore
+	PackageParser  PackageParser
+}
+
+// InstallChaincode installs a given chaincode to the peer's chaincode store.
+// It returns the hash to reference the chaincode by or an error on failure.
+func (l *Lifecycle) InstallChaincode(name, version string, chaincodeInstallPackage []byte) ([]byte, error) {
+	// Let's validate that the chaincodeInstallPackage is at least well formed before writing it
+	_, err := l.PackageParser.Parse(chaincodeInstallPackage)
+	if err != nil {
+		return nil, errors.WithMessage(err, "could not parse as a chaincode install package")
+	}
+
+	hash, err := l.ChaincodeStore.Save(name, version, chaincodeInstallPackage)
+	if err != nil {
+		return nil, errors.WithMessage(err, "could not save cc install package")
+	}
+
+	return hash, nil
+}

core/chaincode/lifecycle/lifecycle_suite_test.go

@@ -12,6 +12,7 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 
+	"github.com/hyperledger/fabric/core/chaincode/lifecycle"
 	"github.com/hyperledger/fabric/core/chaincode/shim"
 )
 
@@ -20,6 +21,16 @@ type chaincodeStub interface {
 	shim.ChaincodeStubInterface
 }
 
+//go:generate counterfeiter -o mock/chaincode_store.go --fake-name ChaincodeStore . chaincodeStore
+type chaincodeStore interface {
+	lifecycle.ChaincodeStore
+}
+
+//go:generate counterfeiter -o mock/package_parser.go --fake-name PackageParser . packageParser
+type packageParser interface {
+	lifecycle.PackageParser
+}
+
 func TestLifecycle(t *testing.T) {
 	RegisterFailHandler(Fail)
 	RunSpecs(t, "Lifecycle Suite")

core/chaincode/lifecycle/lifecycle_test.go

@@ -0,0 +1,80 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package lifecycle_test
+
+import (
+	"fmt"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/hyperledger/fabric/core/chaincode/lifecycle"
+	"github.com/hyperledger/fabric/core/chaincode/lifecycle/mock"
+)
+
+var _ = Describe("Lifecycle", func() {
+	var (
+		l           *lifecycle.Lifecycle
+		fakeCCStore *mock.ChaincodeStore
+		fakeParser  *mock.PackageParser
+	)
+
+	BeforeEach(func() {
+		fakeCCStore = &mock.ChaincodeStore{}
+		fakeParser = &mock.PackageParser{}
+
+		l = &lifecycle.Lifecycle{
+			PackageParser:  fakeParser,
+			ChaincodeStore: fakeCCStore,
+		}
+	})
+
+	Describe("InstallChaincode", func() {
+		BeforeEach(func() {
+			fakeCCStore.SaveReturns([]byte("fake-hash"), nil)
+		})
+
+		It("saves the chaincode", func() {
+			hash, err := l.InstallChaincode("name", "version", []byte("cc-package"))
+			Expect(err).NotTo(HaveOccurred())
+			Expect(hash).To(Equal([]byte("fake-hash")))
+
+			Expect(fakeParser.ParseCallCount()).To(Equal(1))
+			Expect(fakeParser.ParseArgsForCall(0)).To(Equal([]byte("cc-package")))
+
+			Expect(fakeCCStore.SaveCallCount()).To(Equal(1))
+			name, version, msg := fakeCCStore.SaveArgsForCall(0)
+			Expect(name).To(Equal("name"))
+			Expect(version).To(Equal("version"))
+			Expect(msg).To(Equal([]byte("cc-package")))
+		})
+
+		Context("when saving the chaincode fails", func() {
+			BeforeEach(func() {
+				fakeCCStore.SaveReturns(nil, fmt.Errorf("fake-error"))
+			})
+
+			It("wraps and returns the error", func() {
+				hash, err := l.InstallChaincode("name", "version", []byte("cc-package"))
+				Expect(hash).To(BeNil())
+				Expect(err).To(MatchError("could not save cc install package: fake-error"))
+			})
+		})
+
+		Context("when parsing the chaincode package fails", func() {
+			BeforeEach(func() {
+				fakeParser.ParseReturns(nil, fmt.Errorf("parse-error"))
+			})
+
+			It("wraps and returns the error", func() {
+				hash, err := l.InstallChaincode("name", "version", []byte("fake-package"))
+				Expect(hash).To(BeNil())
+				Expect(err).To(MatchError("could not parse as a chaincode install package: parse-error"))
+			})
+		})
+	})
+})