[FAB-7696] Add couch indexes to node cc install pkg

This change packages index metadata for node.js
chaincode. It has the same behavior as the golang
packaging recently introduced in FAB-7132.

Allow indexes that support chaincode queries to be defined
alongside chaincode.  Any index defined in chaincode directory
META-INF/statedb/couchdb/indexes will get added to the chaincode
deployment spec code package, so that when the chaincode
is both installed on a peer and instantiated on a channel,
the indexes can be automatically deployed to couchdb.

Change-Id: I1670e77508f496fd839a4df2480350184c870fab
Signed-off-by: David Enyeart <enyeart@us.ibm.com>

Author: denyeart

core/chaincode/platforms/node/platform.go

@@ -143,7 +143,8 @@ func (nodePlatform *Platform) GetDeploymentPayload(spec *pb.ChaincodeSpec) ([]by
 		return nil, errors.New("ChaincodeSpec's path cannot be empty")
 	}
 
-	if strings.LastIndex(folder, "/") == len(folder)-1 {
+	// trim trailing slash if it exists
+	if folder[len(folder)-1] == '/' {
 		folder = folder[:len(folder)-1]
 	}
 

core/container/util/writer.go

@@ -28,9 +28,18 @@ var javaExcludeFileTypes = map[string]bool{
 	".class": true,
 }
 
+// WriteFolderToTarPackage writes source files to a tarball.
+// This utility is used for node js chaincode packaging, but not golang chaincode.
+// Golang chaincode has more sophisticated file packaging, as implemented in golang/platform.go.
 func WriteFolderToTarPackage(tw *tar.Writer, srcPath string, excludeDir string, includeFileTypeMap map[string]bool, excludeFileTypeMap map[string]bool) error {
 	fileCount := 0
 	rootDirectory := srcPath
+
+	// trim trailing slash if it was passed
+	if rootDirectory[len(rootDirectory)-1] == '/' {
+		rootDirectory = rootDirectory[:len(rootDirectory)-1]
+	}
+
 	vmLogger.Infof("rootDirectory = %s", rootDirectory)
 
 	//append "/" if necessary
@@ -75,8 +84,14 @@ func WriteFolderToTarPackage(tw *tar.Writer, srcPath string, excludeDir string,
 			}
 		}
 
-		newPath := fmt.Sprintf("src%s", path[rootDirLen:])
-		//newPath := path[len(rootDirectory):]
+		var newPath string
+		// if file is metadata, keep the /META-INF directory, e.g: META-INF/statedb/couchdb/indexes/indexOwner.json
+		// otherwise file is source code, put it in /src dir, e.g: src/marbles_chaincode.js
+		if strings.HasPrefix(path, filepath.Join(rootDirectory, "META-INF")) {
+			newPath = path[rootDirLen+1:]
+		} else {
+			newPath = fmt.Sprintf("src%s", path[rootDirLen:])
+		}
 
 		err = WriteFileToPackage(path, newPath, tw)
 		if err != nil {
@@ -120,6 +135,7 @@ func WriteJavaProjectToPackage(tw *tar.Writer, srcPath string) error {
 
 //WriteFileToPackage writes a file to the tarball
 func WriteFileToPackage(localpath string, packagepath string, tw *tar.Writer) error {
+	vmLogger.Debug("Writing file to tarball:", packagepath)
 	fd, err := os.Open(localpath)
 	if err != nil {
 		return fmt.Errorf("%s: %s", localpath, err)

core/container/util/writer_test.go

@@ -11,6 +11,7 @@ import (
 	"bytes"
 	"compress/gzip"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -42,6 +43,7 @@ func Test_WriteFileToPackage(t *testing.T) {
 	// Read the file from the archive and check the name and file content
 	r := bytes.NewReader(buf.Bytes())
 	gr, err1 := gzip.NewReader(r)
+	defer gr.Close()
 	assert.NoError(t, err1, "Error creating a gzip reader")
 	tr := tar.NewReader(gr)
 	header, err2 := tr.Next()
@@ -110,6 +112,7 @@ func Test_WriteStreamToPackage(t *testing.T) {
 	// Read the file from the archive and check the name and file content
 	br := bytes.NewReader(buf.Bytes())
 	gr, err1 := gzip.NewReader(br)
+	defer gr.Close()
 	assert.NoError(t, err1, "Error creating a gzip reader")
 	tr := tar.NewReader(gr)
 	header, err2 := tr.Next()
@@ -124,14 +127,12 @@ func Test_WriteStreamToPackage(t *testing.T) {
 		"file content from the archive is not same as original file content")
 }
 
-func Test_WriteFolderToTarPackage(t *testing.T) {
-	buf := bytes.NewBuffer(nil)
-	gw := gzip.NewWriter(buf)
-	tw := tar.NewWriter(gw)
+// Success case 1: with include and exclude file types and without exclude dir
+func Test_WriteFolderToTarPackage1(t *testing.T) {
 
-	// Success case 1: with include and exclude file types and without exclude dir
 	gopath := os.Getenv("GOPATH")
 	gopath = filepath.SplitList(gopath)[0]
+
 	srcPath := filepath.Join(gopath, "src",
 		"github.com/hyperledger/fabric/examples/chaincode/java/SimpleSample")
 	filePath := "src/src/main/java/example/SimpleSample.java"
@@ -142,41 +143,137 @@ func Test_WriteFolderToTarPackage(t *testing.T) {
 		".xml": true,
 	}
 
-	err := WriteFolderToTarPackage(tw, srcPath, "",
-		includeFileTypes, excludeFileTypes)
-	assert.NoError(t, err, "Error writing folder to package")
-
-	tw.Close()
-	gw.Close()
+	tarBytes := createTestTar(t, srcPath, "", includeFileTypes, excludeFileTypes)
 
 	// Read the file from the archive and check the name
-	br := bytes.NewReader(buf.Bytes())
+	br := bytes.NewReader(tarBytes)
 	gr, err1 := gzip.NewReader(br)
+	defer gr.Close()
 	assert.NoError(t, err1, "Error creating a gzip reader")
 	tr := tar.NewReader(gr)
 	header, err2 := tr.Next()
 	assert.NoError(t, err2, "Error getting the file from the tar")
 	assert.Equal(t, filePath, header.Name,
 		"Name of the file read from the archive is not same as the file added to the archive")
+}
 
-	// Success case 2: with exclude dir and no include file types
-	srcPath = filepath.Join(gopath, "src",
+// Success case 2: with exclude dir and no include file types
+func Test_WriteFolderToTarPackage2(t *testing.T) {
+
+	gopath := os.Getenv("GOPATH")
+	gopath = filepath.SplitList(gopath)[0]
+
+	srcPath := filepath.Join(gopath, "src",
 		"github.com/hyperledger/fabric/examples/chaincode/java")
-	tarw := tar.NewWriter(bytes.NewBuffer(nil))
-	defer tarw.Close()
-	err = WriteFolderToTarPackage(tarw, srcPath, "SimpleSample",
-		nil, excludeFileTypes)
+	excludeFileTypes := map[string]bool{
+		".xml": true,
+	}
+
+	createTestTar(t, srcPath, "SimpleSample", nil, excludeFileTypes)
+}
+
+// Success case 3: with chaincode metadata in META-INF directory
+func Test_WriteFolderToTarPackage3(t *testing.T) {
+
+	gopath := os.Getenv("GOPATH")
+	gopath = filepath.SplitList(gopath)[0]
+
+	// Note - go chaincode does not use WriteFolderToTarPackage(),
+	// but we can still use the go example for unit test,
+	// since there are no node chaincode examples in fabric repos
+	srcPath := filepath.Join(gopath, "src",
+		"github.com/hyperledger/fabric/examples/chaincode/go/marbles02")
+	filePath := "META-INF/statedb/couchdb/indexes/indexOwner.json"
+
+	tarBytes := createTestTar(t, srcPath, "", nil, nil)
+
+	// Read the files from the archive and check for the metadata index file
+	br := bytes.NewReader(tarBytes)
+	gr, err := gzip.NewReader(br)
+	defer gr.Close()
+	assert.NoError(t, err, "Error creating a gzip reader")
+	tr := tar.NewReader(gr)
+	var foundIndexArtifact bool
+	for {
+		header, err := tr.Next()
+		if err == io.EOF { // No more entries
+			break
+		}
+		assert.NoError(t, err, "Error getting Next() file in tar")
+		t.Logf("Found file in tar: %s", header.Name)
+		if header.Name == filePath {
+			foundIndexArtifact = true
+			break
+		}
+	}
+	assert.True(t, foundIndexArtifact, "should have found statedb index artifact in marbles02 META-INF directory")
+}
+
+// Success case 4: with chaincode metadata in META-INF directory, pass trailing slash in srcPath
+func Test_WriteFolderToTarPackage4(t *testing.T) {
+
+	gopath := os.Getenv("GOPATH")
+	gopath = filepath.SplitList(gopath)[0]
+
+	// Note - go chaincode does not use WriteFolderToTarPackage(),
+	// but we can still use the go example for unit test,
+	// since there are no node chaincode examples in fabric repos
+	srcPath := filepath.Join(gopath, "src",
+		"github.com/hyperledger/fabric/examples/chaincode/go/marbles02")
+	srcPath = srcPath + "/"
+	filePath := "META-INF/statedb/couchdb/indexes/indexOwner.json"
+
+	tarBytes := createTestTar(t, srcPath, "", nil, nil)
+
+	// Read the files from the archive and check for the metadata index file
+	br := bytes.NewReader(tarBytes)
+	gr, err := gzip.NewReader(br)
+	defer gr.Close()
+	assert.NoError(t, err, "Error creating a gzip reader")
+	tr := tar.NewReader(gr)
+	var foundIndexArtifact bool
+	for {
+		header, err := tr.Next()
+		if err == io.EOF { // No more entries
+			break
+		}
+		assert.NoError(t, err, "Error getting Next() file in tar")
+		t.Logf("Found file in tar: %s", header.Name)
+		if header.Name == filePath {
+			foundIndexArtifact = true
+			break
+		}
+	}
+	assert.True(t, foundIndexArtifact, "should have found statedb index artifact in marbles02 META-INF directory")
+}
+
+func createTestTar(t *testing.T, srcPath string, excludeDir string, includeFileTypeMap map[string]bool, excludeFileTypeMap map[string]bool) []byte {
+	buf := bytes.NewBuffer(nil)
+	gw := gzip.NewWriter(buf)
+	tw := tar.NewWriter(gw)
+
+	err := WriteFolderToTarPackage(tw, srcPath, "", includeFileTypeMap, excludeFileTypeMap)
 	assert.NoError(t, err, "Error writing folder to package")
 
-	// Failure case 1: no files in directory
-	srcPath = filepath.Join(gopath, "src",
+	tw.Close()
+	gw.Close()
+	return buf.Bytes()
+}
+
+// Failure case 1: no files in directory
+func Test_WriteFolderToTarPackageFailure1(t *testing.T) {
+	gopath := os.Getenv("GOPATH")
+	gopath = filepath.SplitList(gopath)[0]
+
+	srcPath := filepath.Join(gopath, "src",
 		"github.com/hyperledger/fabric/core/container/util",
 		fmt.Sprintf("%d", os.Getpid()))
 	os.Mkdir(srcPath, os.ModePerm)
 	defer os.Remove(srcPath)
-	tarw = tar.NewWriter(bytes.NewBuffer(nil))
-	defer tarw.Close()
-	err = WriteFolderToTarPackage(tw, srcPath, "", nil, nil)
+
+	tw := tar.NewWriter(bytes.NewBuffer(nil))
+	defer tw.Close()
+	err := WriteFolderToTarPackage(tw, srcPath, "", nil, nil)
 	assert.Contains(t, err.Error(), "no source files found")
 }