[FAB-14923] remove WriteJavaProjectToPackage

A chaincode language specific function should not be defined next to the
functions it uses simply because it calls them.

Removed WriteJavaProjectToPackage and used the underlying implementation
in platforms/java package.

Change-Id: I46193cfa8d7a48cf186be61c77abcebef132fc8a
Signed-off-by: Matthew Sykes <sykesmat@us.ibm.com>

Author: sykesm

core/chaincode/platforms/java/platform.go

@@ -3,6 +3,7 @@ Copyright DTCC 2016 All Rights Reserved.
 
 SPDX-License-Identifier: Apache-2.0
 */
+
 package java
 
 import (
@@ -26,8 +27,7 @@ import (
 var logger = flogging.MustGetLogger("chaincode.platform.java")
 
 // Platform for java chaincodes in java
-type Platform struct {
-}
+type Platform struct{}
 
 // Name returns the name of this platform
 func (javaPlatform *Platform) Name() string {
@@ -63,13 +63,11 @@ func (javaPlatform *Platform) ValidateCodePackage(code []byte) error {
 
 	for {
 		header, err := tr.Next()
+		if err == io.EOF {
+			break
+		}
 		if err != nil {
-			if err == io.EOF {
-				// We only get here if there are no more entries to scan
-				break
-			} else {
-				return err
-			}
+			return err
 		}
 
 		// --------------------------------------------------------------------------------------
@@ -97,38 +95,34 @@ func (javaPlatform *Platform) ValidateCodePackage(code []byte) error {
 
 // WritePackage writes the java chaincode package
 func (javaPlatform *Platform) GetDeploymentPayload(path string) ([]byte, error) {
-
 	logger.Debugf("Packaging java project from path %s", path)
-	var err error
 
-	// --------------------------------------------------------------------------------------
-	// Write out our tar package
-	// --------------------------------------------------------------------------------------
-	payload := bytes.NewBuffer(nil)
-	gw := gzip.NewWriter(payload)
-	tw := tar.NewWriter(gw)
-
-	folder := path
-	if folder == "" {
+	if path == "" {
 		logger.Error("ChaincodeSpec's path cannot be empty")
 		return nil, errors.New("ChaincodeSpec's path cannot be empty")
 	}
 
 	// trim trailing slash if it exists
-	if folder[len(folder)-1] == '/' {
-		folder = folder[:len(folder)-1]
+	if path[len(path)-1] == '/' {
+		path = path[:len(path)-1]
 	}
 
-	if err = cutil.WriteJavaProjectToPackage(tw, folder); err != nil {
+	buf := &bytes.Buffer{}
+	gw := gzip.NewWriter(buf)
+	tw := tar.NewWriter(gw)
 
+	excludedDirs := []string{"target", "build", "out"}
+	excludedFileTypes := map[string]bool{".class": true}
+	err := cutil.WriteFolderToTarPackage(tw, path, excludedDirs, nil, excludedFileTypes)
+	if err != nil {
 		logger.Errorf("Error writing java project to tar package %s", err)
-		return nil, fmt.Errorf("Error writing Chaincode package contents: %s", err)
+		return nil, fmt.Errorf("failed to create chaincode package: %s", err)
 	}
 
 	tw.Close()
 	gw.Close()
 
-	return payload.Bytes(), nil
+	return buf.Bytes(), nil
 }
 
 func (javaPlatform *Platform) GenerateDockerfile() (string, error) {

core/chaincode/platforms/java/java_test.go renamed to core/chaincode/platforms/java/platform_test.go

@@ -11,6 +11,7 @@ import (
 	"bytes"
 	"compress/gzip"
 	"fmt"
+	"io"
 	"os"
 	"strings"
 	"testing"
@@ -22,18 +23,36 @@ import (
 	pb "github.com/hyperledger/fabric/protos/peer"
 	"github.com/spf13/viper"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
-const chaincodePathFolder = "testdata"
-const chaincodePathFolderGradle = chaincodePathFolder + "/gradle"
+const chaincodePathFolderGradle = "testdata/gradle"
 
 var spec = &pb.ChaincodeSpec{
 	Type: pb.ChaincodeSpec_JAVA,
 	ChaincodeId: &pb.ChaincodeID{
 		Name: "ssample",
-		Path: chaincodePathFolderGradle},
+		Path: chaincodePathFolderGradle,
+	},
 	Input: &pb.ChaincodeInput{
-		Args: [][]byte{[]byte("f")}}}
+		Args: [][]byte{
+			[]byte("f"),
+		},
+	},
+}
+
+func TestMain(m *testing.M) {
+	viper.SetConfigName("core")
+	viper.SetEnvPrefix("CORE")
+	configtest.AddDevConfigPath(nil)
+	viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+	viper.AutomaticEnv()
+	if err := viper.ReadInConfig(); err != nil {
+		fmt.Printf("could not read config %s\n", err)
+		os.Exit(-1)
+	}
+	os.Exit(m.Run())
+}
 
 func TestValidatePath(t *testing.T) {
 	platform := java.Platform{}
@@ -84,25 +103,20 @@ func TestGetDeploymentPayload(t *testing.T) {
 	assert.NoError(t, err)
 	assert.NotZero(t, len(payload))
 
-	buildFileFound := false
-	settingsFileFound := false
-	pomFileFound := false
-	srcFileFound := false
-
 	is := bytes.NewReader(payload)
 	gr, err := gzip.NewReader(is)
-	if err != nil {
-		assert.Failf(t, "Can't open zip stream %s", err.Error())
-	}
+	require.NoError(t, err, "failed to open zip stream")
 	defer gr.Close()
 
 	tr := tar.NewReader(gr)
 
+	contents := map[string]bool{}
 	for {
 		header, err := tr.Next()
-		if err != nil {
+		if err == io.EOF {
 			break
 		}
+		assert.NoError(t, err)
 
 		if strings.Contains(header.Name, ".class") {
 			assert.Fail(t, "Result package can't contain class file")
@@ -113,24 +127,14 @@ func TestGetDeploymentPayload(t *testing.T) {
 		if strings.Contains(header.Name, "build/") {
 			assert.Fail(t, "Result package can't contain build folder")
 		}
-		if strings.Contains(header.Name, "src/build.gradle") {
-			buildFileFound = true
-		}
-		if strings.Contains(header.Name, "src/settings.gradle") {
-			settingsFileFound = true
-		}
-		if strings.Contains(header.Name, "src/pom.xml") {
-			pomFileFound = true
-		}
-		if strings.Contains(header.Name, "src/main/java/example/ExampleCC.java") {
-			srcFileFound = true
-		}
+		contents[header.Name] = true
 	}
-	assert.True(t, buildFileFound, "Can't find build.gradle file in tar")
-	assert.True(t, settingsFileFound, "Can't find settings.gradle file in tar")
-	assert.True(t, pomFileFound, "Can't find pom.xml file in tar")
-	assert.True(t, srcFileFound, "Can't find example.cc file in tar")
-	assert.NoError(t, err, "Error while scanning tar file")
+
+	// generated from observed behavior
+	assert.Contains(t, contents, "src/build.gradle")
+	assert.Contains(t, contents, "src/pom.xml")
+	assert.Contains(t, contents, "src/settings.gradle")
+	assert.Contains(t, contents, "src/src/main/java/example/ExampleCC.java")
 }
 
 func TestGenerateDockerfile(t *testing.T) {
@@ -177,19 +181,6 @@ func TestGenerateDockerBuild(t *testing.T) {
 	assert.NoError(t, err)
 }
 
-func TestMain(m *testing.M) {
-	viper.SetConfigName("core")
-	viper.SetEnvPrefix("CORE")
-	configtest.AddDevConfigPath(nil)
-	viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
-	viper.AutomaticEnv()
-	if err := viper.ReadInConfig(); err != nil {
-		fmt.Printf("could not read config %s\n", err)
-		os.Exit(-1)
-	}
-	os.Exit(m.Run())
-}
-
 func generateMockPackegeBytes(fileName string, mode int64) ([]byte, error) {
 	var zeroTime time.Time
 	codePackage := bytes.NewBuffer(nil)

core/container/util/writer.go

@@ -144,24 +144,6 @@ func WriteFolderToTarPackage(tw *tar.Writer, srcPath string, excludeDirs []strin
 	return nil
 }
 
-//Package Java project to tar file from the source path
-func WriteJavaProjectToPackage(tw *tar.Writer, srcPath string) error {
-
-	vmLogger.Debugf("Packaging Java project from path %s", srcPath)
-
-	if err := WriteFolderToTarPackage(tw, srcPath, []string{"target", "build", "out"}, nil, javaExcludeFileTypes); err != nil {
-
-		vmLogger.Errorf("Error writing folder to tar package %s", err)
-		return err
-	}
-	// Write the tar file out
-	if err := tw.Close(); err != nil {
-		return err
-	}
-	return nil
-
-}
-
 //WriteFileToPackage writes a file to the tarball
 func WriteFileToPackage(localpath string, packagepath string, tw *tar.Writer) error {
 	vmLogger.Debug("Writing file to tarball:", packagepath)

core/container/util/writer_test.go

@@ -237,32 +237,6 @@ func Test_WriteFolderToTarPackageFailure3(t *testing.T) {
 	gw.Close()
 }
 
-func Test_WriteJavaProjectToPackage(t *testing.T) {
-	inputbuf := bytes.NewBuffer(nil)
-	gw := gzip.NewWriter(inputbuf)
-	tw := tar.NewWriter(gw)
-
-	srcPath := filepath.Join("testdata", "sourcefiles")
-	assert.FileExists(t, filepath.Join(srcPath, "src", "Hello.class"))
-
-	err := WriteJavaProjectToPackage(tw, srcPath)
-	assert.NoError(t, err, "Error writing java project to package")
-
-	// Close the tar writer and call WriteFileToPackage again, this should
-	// return an error
-	tw.Close()
-	gw.Close()
-
-	entries := tarContents(t, inputbuf.Bytes())
-	assert.Contains(t, entries, "META-INF/statedb/couchdb/indexes/indexOwner.json")
-	assert.Contains(t, entries, "src/artifact.xml")
-	assert.Contains(t, entries, "src/src/Hello.java")
-	assert.NotContains(t, entries, "src/src/Hello.class")
-
-	err = WriteJavaProjectToPackage(tw, srcPath)
-	assert.Error(t, err, "WriteJavaProjectToPackage was called with closed writer, should have failed")
-}
-
 func Test_WriteBytesToPackage(t *testing.T) {
 	inputbuf := bytes.NewBuffer(nil)
 	tw := tar.NewWriter(inputbuf)