Merge "FAB-17001 Delete chaincode package on build fail"

core/chaincode/lifecycle/lifecycle.go

@@ -184,6 +184,7 @@ type ChaincodeStore interface {
 	Save(label string, ccInstallPkg []byte) (string, error)
 	ListInstalledChaincodes() ([]chaincode.InstalledChaincode, error)
 	Load(packageID string) (ccInstallPkg []byte, err error)
+	Delete(packageID string) error
 }
 
 type PackageParser interface {
@@ -495,20 +496,21 @@ func (ef *ExternalFunctions) InstallChaincode(chaincodeInstallPackage []byte) (*
 		return nil, errors.WithMessage(err, "could not save cc install package")
 	}
 
-	if ef.InstallListener != nil {
-		ef.InstallListener.HandleChaincodeInstalled(pkg.Metadata, packageID)
-	}
-
 	buildStatus, ok := ef.BuildRegistry.BuildStatus(packageID)
 	if !ok {
 		err := ef.ChaincodeBuilder.Build(packageID)
 		buildStatus.Notify(err)
 	}
 	<-buildStatus.Done()
 	if err := buildStatus.Err(); err != nil {
+		ef.Resources.ChaincodeStore.Delete(packageID)
 		return nil, errors.WithMessage(err, "could not build chaincode")
 	}
 
+	if ef.InstallListener != nil {
+		ef.InstallListener.HandleChaincodeInstalled(pkg.Metadata, packageID)
+	}
+
 	logger.Infof("successfully installed chaincode with package ID '%s'", packageID)
 
 	return &chaincode.InstalledChaincode{

core/chaincode/lifecycle/lifecycle_test.go

@@ -289,6 +289,12 @@ var _ = Describe("ExternalFunctions", func() {
 				_, err := ef.InstallChaincode([]byte("cc-package"))
 				Expect(err).To(MatchError("could not build chaincode: fake-build-error"))
 			})
+
+			It("deletes the chaincode from disk", func() {
+				ef.InstallChaincode([]byte("cc-package"))
+				Expect(fakeCCStore.DeleteCallCount()).To(Equal(1))
+				Expect(fakeCCStore.DeleteArgsForCall(0)).To(Equal("fake-hash"))
+			})
 		})
 
 		When("the chaincode is already being built", func() {

core/chaincode/persistence/persistence.go

@@ -188,6 +188,14 @@ func (s *Store) Load(packageID string) ([]byte, error) {
 	return ccInstallPkg, nil
 }
 
+// Delete deletes a persisted chaincode.  Note, there is no locking,
+// so this should only be performed if the chaincode has already
+// been marked built.
+func (s *Store) Delete(packageID string) error {
+	ccInstallPkgPath := filepath.Join(s.Path, CCFileName(packageID))
+	return s.ReadWriter.Remove(ccInstallPkgPath)
+}
+
 // CodePackageNotFoundErr is the error returned when a code package cannot
 // be found in the persistence store
 type CodePackageNotFoundErr struct {

core/chaincode/persistence/persistence_test.go

@@ -261,6 +261,40 @@ var _ = Describe("Persistence", func() {
 		})
 	})
 
+	Describe("Delete", func() {
+		var (
+			mockReadWriter *mock.IOReadWriter
+			store          *persistence.Store
+		)
+
+		BeforeEach(func() {
+			mockReadWriter = &mock.IOReadWriter{}
+			store = &persistence.Store{
+				ReadWriter: mockReadWriter,
+				Path:       "foo",
+			}
+		})
+
+		It("removes the chaincode from the filesystem", func() {
+			err := store.Delete("hash")
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(mockReadWriter.RemoveCallCount()).To(Equal(1))
+			Expect(mockReadWriter.RemoveArgsForCall(0)).To(Equal("foo/hash.tar.gz"))
+		})
+
+		When("remove returns an error", func() {
+			BeforeEach(func() {
+				mockReadWriter.RemoveReturns(fmt.Errorf("fake-remove-error"))
+			})
+
+			It("returns the error", func() {
+				err := store.Delete("hash")
+				Expect(err).To(MatchError("fake-remove-error"))
+			})
+		})
+	})
+
 	Describe("Load", func() {
 		var (
 			mockReadWriter *mock.IOReadWriter