FAB-16599 Wire externalbuilder MD provider

This CR takes the new externalbuilder MD provider and wires it through
to the assorted places where the ledger needs to be provided with the
chaincode metadata (such as couchdb indices).

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

Author: Jason Yellick

core/chaincode/lifecycle/cache.go

@@ -16,6 +16,7 @@ import (
 	"github.com/hyperledger/fabric/common/chaincode"
 	"github.com/hyperledger/fabric/common/util"
 	"github.com/hyperledger/fabric/core/chaincode/persistence"
+	"github.com/hyperledger/fabric/core/container/externalbuilders"
 	"github.com/hyperledger/fabric/core/ledger"
 	"github.com/hyperledger/fabric/protoutil"
 
@@ -121,14 +122,14 @@ func (l *LocalChaincode) createMetadataMapFromReferences() map[string][]*chainco
 	return references
 }
 
-func NewCache(resources *Resources, myOrgMSPID string, metadataManager MetadataHandler, custodian *ChaincodeCustodian) *Cache {
+func NewCache(resources *Resources, myOrgMSPID string, metadataManager MetadataHandler, custodian *ChaincodeCustodian, ebMetadata *externalbuilders.MetadataProvider) *Cache {
 	return &Cache{
 		chaincodeCustodian: custodian,
 		definedChaincodes:  map[string]*ChannelCache{},
 		localChaincodes:    map[string]*LocalChaincode{},
 		Resources:          resources,
 		MyOrgMSPID:         myOrgMSPID,
-		eventBroker:        NewEventBroker(resources.ChaincodeStore, resources.PackageParser),
+		eventBroker:        NewEventBroker(resources.ChaincodeStore, resources.PackageParser, ebMetadata),
 		MetadataHandler:    metadataManager,
 	}
 }

core/chaincode/lifecycle/cache_test.go

@@ -20,6 +20,7 @@ import (
 	"github.com/hyperledger/fabric/core/chaincode/lifecycle/mock"
 	"github.com/hyperledger/fabric/core/chaincode/persistence"
 	"github.com/hyperledger/fabric/core/container"
+	"github.com/hyperledger/fabric/core/container/externalbuilders"
 	"github.com/hyperledger/fabric/core/ledger"
 	ledgermock "github.com/hyperledger/fabric/core/ledger/mock"
 	"github.com/hyperledger/fabric/protoutil"
@@ -75,7 +76,7 @@ var _ = Describe("Cache", func() {
 		chaincodeCustodian = lifecycle.NewChaincodeCustodian()
 
 		var err error
-		c = lifecycle.NewCache(resources, "my-mspid", fakeMetadataHandler, chaincodeCustodian)
+		c = lifecycle.NewCache(resources, "my-mspid", fakeMetadataHandler, chaincodeCustodian, &externalbuilders.MetadataProvider{})
 		Expect(err).NotTo(HaveOccurred())
 
 		channelCache = &lifecycle.ChannelCache{

core/chaincode/lifecycle/event_broker.go

@@ -8,23 +8,26 @@ package lifecycle
 import (
 	"sync"
 
+	"github.com/hyperledger/fabric/core/container/externalbuilders"
 	"github.com/hyperledger/fabric/core/ledger"
 	"github.com/pkg/errors"
 )
 
 // EventBroker receives events from lifecycle cache and in turn invokes the registered listeners
 type EventBroker struct {
 	chaincodeStore       ChaincodeStore
+	ebMetadata           *externalbuilders.MetadataProvider
 	pkgParser            PackageParser
 	defineCallbackStatus *sync.Map
 
 	mutex     sync.Mutex
 	listeners map[string][]ledger.ChaincodeLifecycleEventListener
 }
 
-func NewEventBroker(chaincodeStore ChaincodeStore, pkgParser PackageParser) *EventBroker {
+func NewEventBroker(chaincodeStore ChaincodeStore, pkgParser PackageParser, ebMetadata *externalbuilders.MetadataProvider) *EventBroker {
 	return &EventBroker{
 		chaincodeStore:       chaincodeStore,
+		ebMetadata:           ebMetadata,
 		pkgParser:            pkgParser,
 		listeners:            make(map[string][]ledger.ChaincodeLifecycleEventListener),
 		defineCallbackStatus: &sync.Map{},
@@ -154,6 +157,15 @@ func (b *EventBroker) invokeDoneOnListeners(channelID string, succeeded bool) {
 }
 
 func (b *EventBroker) loadDBArtifacts(packageID string) ([]byte, error) {
+	md, err := b.ebMetadata.PackageMetadata(packageID)
+	if err != nil {
+		return nil, err
+	}
+
+	if md != nil {
+		return md, nil
+	}
+
 	pkgBytes, err := b.chaincodeStore.Load(packageID)
 	if err != nil {
 		return nil, err

core/chaincode/lifecycle/event_broker_test.go

@@ -11,6 +11,8 @@ import (
 	"github.com/hyperledger/fabric/core/chaincode/lifecycle"
 	"github.com/hyperledger/fabric/core/chaincode/lifecycle/mock"
 	"github.com/hyperledger/fabric/core/chaincode/persistence"
+	"github.com/hyperledger/fabric/core/container/externalbuilders"
+	"github.com/hyperledger/fabric/core/ledger"
 	ledgermock "github.com/hyperledger/fabric/core/ledger/mock"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -25,13 +27,17 @@ var _ = Describe("EventBroker", func() {
 		eventBroker        *lifecycle.EventBroker
 		cachedChaincodeDef *lifecycle.CachedChaincodeDefinition
 		localChaincode     *lifecycle.LocalChaincode
+		ebMetadata         *externalbuilders.MetadataProvider
 	)
 
 	BeforeEach(func() {
 		fakeListener = &ledgermock.ChaincodeLifecycleEventListener{}
 		chaincodeStore = &mock.ChaincodeStore{}
 		pkgParser = &mock.PackageParser{}
-		eventBroker = lifecycle.NewEventBroker(chaincodeStore, pkgParser)
+		ebMetadata = &externalbuilders.MetadataProvider{
+			DurablePath: "testdata",
+		}
+		eventBroker = lifecycle.NewEventBroker(chaincodeStore, pkgParser, ebMetadata)
 		cachedChaincodeDef = &lifecycle.CachedChaincodeDefinition{}
 		localChaincode = &lifecycle.LocalChaincode{
 			Info: &lifecycle.ChaincodeInstallInfo{
@@ -141,6 +147,14 @@ var _ = Describe("EventBroker", func() {
 		It("invokes listener", func() {
 			eventBroker.ProcessInstallEvent(localChaincode)
 			Expect(fakeListener.HandleChaincodeDeployCallCount()).To(Equal(1))
+			def, md := fakeListener.HandleChaincodeDeployArgsForCall(0)
+			Expect(def).To(Equal(&ledger.ChaincodeDefinition{
+				Name:    "chaincode-1",
+				Hash:    []byte("PackageID"),
+				Version: "version-1",
+			}))
+			Expect(md).To(Equal([]byte("db-artifacts")))
+
 			Expect(fakeListener.ChaincodeDeployDoneCallCount()).To(Equal(1))
 		})
 
@@ -153,6 +167,24 @@ var _ = Describe("EventBroker", func() {
 			Expect(fakeListener.ChaincodeDeployDoneCallCount()).To(Equal(1))
 		})
 
+		When("the metadata is defined by the external builders", func() {
+			BeforeEach(func() {
+				localChaincode.Info.PackageID = "external-built-cc"
+			})
+
+			It("does not invoke listener", func() {
+				eventBroker.ProcessInstallEvent(localChaincode)
+				Expect(fakeListener.HandleChaincodeDeployCallCount()).To(Equal(1))
+				def, md := fakeListener.HandleChaincodeDeployArgsForCall(0)
+				Expect(def).To(Equal(&ledger.ChaincodeDefinition{
+					Name:    "chaincode-1",
+					Hash:    []byte("external-built-cc"),
+					Version: "version-1",
+				}))
+				Expect(len(md)).To(Equal(2560)) // A tar, and not our mock value
+			})
+		})
+
 		Context("when chaincode store returns error", func() {
 			BeforeEach(func() {
 				chaincodeStore.LoadReturns(nil, errors.New("loading-error"))

core/chaincode/lifecycle/testdata/external-built-cc/release/index.json

@@ -0,0 +1 @@
+{}

core/ledger/kvledger/tests/env.go

@@ -19,6 +19,7 @@ import (
 	"github.com/hyperledger/fabric/common/ledger/util"
 	"github.com/hyperledger/fabric/common/metrics/disabled"
 	"github.com/hyperledger/fabric/core/common/privdata"
+	"github.com/hyperledger/fabric/core/container/externalbuilders"
 	"github.com/hyperledger/fabric/core/ledger"
 	"github.com/hyperledger/fabric/core/ledger/kvledger"
 	"github.com/hyperledger/fabric/core/ledger/ledgermgmt"
@@ -48,7 +49,12 @@ type env struct {
 func newEnv(t *testing.T) *env {
 	cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore())
 	assert.NoError(t, err)
-	return newEnvWithInitializer(t, &ledgermgmt.Initializer{Hasher: cryptoProvider})
+	return newEnvWithInitializer(t, &ledgermgmt.Initializer{
+		Hasher: cryptoProvider,
+		EbMetadataProvider: &externalbuilders.MetadataProvider{
+			DurablePath: "testdata",
+		},
+	})
 }
 
 func newEnvWithInitializer(t *testing.T, initializer *ledgermgmt.Initializer) *env {

core/ledger/ledgermgmt/ledger_mgmt.go

@@ -31,9 +31,14 @@ var ErrLedgerMgmtNotInitialized = errors.New("ledger mgmt should be initialized
 
 // LedgerMgr manages ledgers for all channels
 type LedgerMgr struct {
-	lock           sync.Mutex
-	openedLedgers  map[string]ledger.PeerLedger
-	ledgerProvider ledger.PeerLedgerProvider
+	lock               sync.Mutex
+	openedLedgers      map[string]ledger.PeerLedger
+	ledgerProvider     ledger.PeerLedgerProvider
+	ebMetadataProvider MetadataProvider
+}
+
+type MetadataProvider interface {
+	PackageMetadata(ccid string) ([]byte, error)
 }
 
 // Initializer encapsulates all the external dependencies for the ledger module
@@ -47,6 +52,7 @@ type Initializer struct {
 	HealthCheckRegistry             ledger.HealthCheckRegistry
 	Config                          *ledger.Config
 	Hasher                          ledger.Hasher
+	EbMetadataProvider              MetadataProvider
 }
 
 // NewLedgerMgr creates a new LedgerMgr
@@ -73,8 +79,9 @@ func NewLedgerMgr(initializer *Initializer) *LedgerMgr {
 		panic(fmt.Sprintf("Error in instantiating ledger provider: %s", err))
 	}
 	ledgerMgr := &LedgerMgr{
-		openedLedgers:  make(map[string]ledger.PeerLedger),
-		ledgerProvider: provider,
+		openedLedgers:      make(map[string]ledger.PeerLedger),
+		ledgerProvider:     provider,
+		ebMetadataProvider: initializer.EbMetadataProvider,
 	}
 	// TODO remove the following package level init
 	cceventmgmt.Initialize(&chaincodeInfoProviderImpl{
@@ -219,5 +226,13 @@ func (p *chaincodeInfoProviderImpl) GetDeployedChaincodeInfo(chainid string,
 
 // RetrieveChaincodeArtifacts implements function in the interface cceventmgmt.ChaincodeInfoProvider
 func (p *chaincodeInfoProviderImpl) RetrieveChaincodeArtifacts(chaincodeDefinition *cceventmgmt.ChaincodeDefinition) (installed bool, dbArtifactsTar []byte, err error) {
-	return ccprovider.ExtractStatedbArtifactsForChaincode(chaincodeDefinition.Name + ":" + chaincodeDefinition.Version)
+	ccid := chaincodeDefinition.Name + ":" + chaincodeDefinition.Version
+	md, err := p.ledgerMgr.ebMetadataProvider.PackageMetadata(ccid)
+	if err != nil {
+		return false, nil, err
+	}
+	if md != nil {
+		return true, md, nil
+	}
+	return ccprovider.ExtractStatedbArtifactsForChaincode(ccid)
 }

core/scc/lscc/lscc.go

@@ -28,6 +28,7 @@ import (
 	"github.com/hyperledger/fabric/core/common/privdata"
 	"github.com/hyperledger/fabric/core/common/sysccprovider"
 	"github.com/hyperledger/fabric/core/container"
+	"github.com/hyperledger/fabric/core/container/externalbuilders"
 	"github.com/hyperledger/fabric/core/ledger"
 	"github.com/hyperledger/fabric/core/ledger/cceventmgmt"
 	"github.com/hyperledger/fabric/core/peer"
@@ -161,6 +162,8 @@ type SCC struct {
 
 	ChaincodeBuilder ChaincodeBuilder
 
+	EbMetadataProvider *externalbuilders.MetadataProvider
+
 	// BCCSP instance
 	BCCSP bccsp.BCCSP
 }
@@ -694,13 +697,20 @@ func (lscc *SCC) executeInstall(stub shim.ChaincodeStubInterface, ccbytes []byte
 		return errors.WithMessage(err, "could not build chaincode")
 	}
 
-	// Get any statedb artifacts from the chaincode package, e.g. couchdb index definitions
-	statedbArtifactsTar, err := ccprovider.ExtractStatedbArtifactsFromCCPackage(ccpack)
+	md, err := lscc.EbMetadataProvider.PackageMetadata(ccid)
 	if err != nil {
-		return err
+		return errors.WithMessage(err, "external builder release metadata found, but could not be packaged")
+	}
+
+	if md == nil {
+		// Get any statedb artifacts from the chaincode package, e.g. couchdb index definitions
+		md, err = ccprovider.ExtractStatedbArtifactsFromCCPackage(ccpack)
+		if err != nil {
+			return err
+		}
 	}
 
-	if err = isValidStatedbArtifactsTar(statedbArtifactsTar); err != nil {
+	if err = isValidStatedbArtifactsTar(md); err != nil {
 		return InvalidStatedbArtifactsErr(err.Error())
 	}
 
@@ -713,7 +723,7 @@ func (lscc *SCC) executeInstall(stub shim.ChaincodeStubInterface, ccbytes []byte
 	// any channel's statedb where the chaincode is already instantiated
 	// Note - this step is done prior to PutChaincodeToLocalStorage() since this step is idempotent and harmless until endorsements start,
 	// that is, if there are errors deploying the indexes the chaincode install can safely be re-attempted later.
-	err = cceventmgmt.GetMgr().HandleChaincodeInstall(chaincodeDefinition, statedbArtifactsTar)
+	err = cceventmgmt.GetMgr().HandleChaincodeInstall(chaincodeDefinition, md)
 	defer func() {
 		cceventmgmt.GetMgr().ChaincodeInstallDone(err == nil)
 	}()

core/scc/lscc/lscc_test.go

@@ -35,6 +35,7 @@ import (
 	"github.com/hyperledger/fabric/core/chaincode/lifecycle"
 	"github.com/hyperledger/fabric/core/common/ccprovider"
 	"github.com/hyperledger/fabric/core/container"
+	"github.com/hyperledger/fabric/core/container/externalbuilders"
 	"github.com/hyperledger/fabric/core/ledger/ledgermgmt"
 	"github.com/hyperledger/fabric/core/ledger/ledgermgmt/ledgermgmttest"
 	"github.com/hyperledger/fabric/core/policy"
@@ -164,6 +165,9 @@ func TestInstall(t *testing.T) {
 		BCCSP:            cryptoProvider,
 		BuildRegistry:    &container.BuildRegistry{},
 		ChaincodeBuilder: chaincodeBuilder,
+		EbMetadataProvider: &externalbuilders.MetadataProvider{
+			DurablePath: "testdata",
+		},
 	}
 	stub := shimtest.NewMockStub("lscc", scc)
 	res := stub.MockInit("1", nil)
@@ -196,6 +200,10 @@ func TestInstall(t *testing.T) {
 	testInstall(t, "example02-different", "0", path, false, "could not build chaincode: fake-build-error", "Alice", scc, stub, nil)
 	chaincodeBuilder.BuildReturns(nil)
 
+	// This is a bad test, but it does at least exercise the external builder md path
+	// The integration tests will ultimately ensure that it actually works.
+	testInstall(t, "external-built", "cc", path, false, "", "Alice", scc, stub, nil)
+
 	testInstall(t, "example02-2", "1.0", path, false, "", "Alice", scc, stub, nil)
 	testInstall(t, "example02.go", "0", path, false, InvalidChaincodeNameErr("example02.go").Error(), "Alice", scc, stub, nil)
 	testInstall(t, "", "0", path, false, InvalidChaincodeNameErr("").Error(), "Alice", scc, stub, nil)

core/scc/lscc/testdata/external-build-cc/release/index.json

@@ -0,0 +1 @@
+{}