Resolve conflicting node versions in plans during build [#167707118]

Co-authored-by: David Freilich <dfreilich@pivotal.io>

Author: ndon55555

cmd/detect/main.go

@@ -29,14 +29,15 @@ func main() {
 }
 
 func runDetect(context detect.Detect) (int, error) {
-	version := ""
+	var version, versionSource string
 	nvmrcPath := filepath.Join(context.Application.Root, ".nvmrc")
 	nvmrcExists, err := helper.FileExists(nvmrcPath)
 	if err != nil {
 		return context.Fail(), err
 	}
 
 	if nvmrcExists {
+		versionSource = ".nvmrc"
 		version, err = nvmrc.GetVersion(nvmrcPath, context.Logger)
 		if err != nil {
 			return context.Fail(), err
@@ -51,6 +52,7 @@ func runDetect(context detect.Detect) (int, error) {
 	}
 
 	if buildpackYamlExists {
+		versionSource = "buildpack.yml"
 		bpYml := &node.BuildpackYAML{}
 		err := helper.ReadBuildpackYaml(buildpackYamlPath, bpYml)
 		if err != nil {
@@ -68,7 +70,7 @@ func runDetect(context detect.Detect) (int, error) {
 			Requires: []buildplan.Required{{
 				Name:     node.Dependency,
 				Version:  version,
-				Metadata: buildplan.Metadata{"launch": true},
+				Metadata: buildplan.Metadata{"launch": true, "version-source": versionSource},
 			}},
 		})
 	}

integration/integration_test.go

@@ -13,7 +13,7 @@ import (
 )
 
 var (
-	bp, npmBP string
+	bp string
 )
 
 func TestIntegration(t *testing.T) {

node/node.go

@@ -1,15 +1,23 @@
 package node
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 
+	"github.com/pkg/errors"
+
+	"github.com/Masterminds/semver"
+
+	"github.com/cloudfoundry/libcfbuildpack/buildpackplan"
+
 	"github.com/cloudfoundry/libcfbuildpack/build"
 	"github.com/cloudfoundry/libcfbuildpack/helper"
 	"github.com/cloudfoundry/libcfbuildpack/layers"
 )
 
 const Dependency = "node"
+const VersionSource = "version-source"
 
 type Config struct {
 	OptimizeMemory bool   `yaml:"optimize-memory"`
@@ -138,6 +146,143 @@ func LoadBuildpackYAML(appRoot string) (BuildpackYAML, error) {
 	return buildpackYAML, err
 }
 
+func PriorityPlanMerge(a, b buildpackplan.Plan) (buildpackplan.Plan, error) {
+	aVersion := a.Version
+	bVersion := b.Version
+	aSource := a.Metadata[VersionSource]
+	bSource := b.Metadata[VersionSource]
+
+	if aVersion == "" && bVersion == "" {
+		return mergePlans(a, b, "", nil)
+	} else if aVersion == "" {
+		return mergePlans(a, b, bVersion, bSource)
+	} else if bVersion == "" {
+		return mergePlans(a, b, aVersion, aSource)
+	}
+
+	aPriority := getPriority(aSource)
+	bPriority := getPriority(bSource)
+	if aPriority > bPriority {
+		return mergePlans(a, b, aVersion, aSource)
+	} else if aPriority == bPriority {
+		version, err := getHighestVersion(aVersion, bVersion)
+		if err != nil {
+			return buildpackplan.Plan{}, fmt.Errorf("failed to get the highest version between %s and %s: %v", aVersion, bVersion, err)
+		}
+		return mergePlans(a, b, version, aSource)
+	} else {
+		return mergePlans(a, b, bVersion, bSource)
+	}
+}
+
+func getHighestVersion(aVersion, bVersion string) (string, error) {
+	aSemver, err := semver.NewVersion(aVersion)
+	if err != nil {
+		return "", fmt.Errorf("failed to convert version %s to semver", aVersion)
+	}
+	bSemver, err := semver.NewVersion(bVersion)
+	if err != nil {
+		return "", fmt.Errorf("failed to convert version %s to semver", bVersion)
+	}
+	version := aVersion
+	if aSemver.LessThan(bSemver) {
+		version = bVersion
+	}
+
+	return version, nil
+}
+
+func getPriority(versionSource interface{}) int {
+	priorities := map[interface{}]int{
+		"buildpack.yml": 3,
+		"package.json":  2,
+		".nvmrc":        1,
+		"":              -1,
+	}
+	val, ok := priorities[versionSource]
+
+	// Any source is higher than empty string
+	if !ok {
+		val = 0
+	}
+	return val
+}
+
+func mergePlans(a, b buildpackplan.Plan, version string, versionSource interface{}) (buildpackplan.Plan, error) {
+	aBuildVal, err := getBooleanVal(a.Metadata["build"])
+	if err != nil {
+		return buildpackplan.Plan{}, errors.Wrapf(err, "could not determine 'build' metadata of %s", a.Name)
+	}
+
+	bBuildVal, err := getBooleanVal(b.Metadata["build"])
+	if err != nil {
+		return buildpackplan.Plan{}, errors.Wrapf(err, "could not determine 'build' metadata of %s", b.Name)
+	}
+
+	aLaunchVal, err := getBooleanVal(a.Metadata["launch"])
+	if err != nil {
+		return buildpackplan.Plan{}, errors.Wrapf(err, "could not determine 'launch' metadata of %s", a.Name)
+	}
+
+	bLaunchVal, err := getBooleanVal(b.Metadata["launch"])
+	if err != nil {
+		return buildpackplan.Plan{}, errors.Wrapf(err, "could not determine 'launch' metadata of %s", b.Name)
+	}
+
+	metadata := a.Metadata // NOTE: Mutating metadata also mutates a.Metadata
+	for key, val := range b.Metadata {
+		ignoreKeys := []string{VersionSource, "build", "launch"}
+		if !contains(ignoreKeys, key) && val != "" {
+			if aVal, ok := metadata[key]; ok && aVal != "" && aVal != val {
+				val = aVal.(string) + "," + val.(string)
+			}
+			metadata[key] = val
+		}
+	}
+
+	if versionSource != nil && versionSource != "" {
+		metadata[VersionSource] = versionSource
+	}
+
+	if aBuildVal || bBuildVal {
+		metadata["build"] = true
+	}
+
+	if aLaunchVal || bLaunchVal {
+		metadata["launch"] = true
+	}
+
+	return buildpackplan.Plan{
+		Name:     a.Name,
+		Version:  version,
+		Metadata: metadata,
+	}, nil
+}
+
+func contains(slice []string, val string) bool {
+	for _, x := range slice {
+		if x == val {
+			return true
+		}
+	}
+
+	return false
+}
+
+func getBooleanVal(val interface{}) (bool, error) {
+	if val == nil || val == "" {
+		return false, nil
+	}
+
+	if b, isString := val.(string); isString {
+		return b == "true", nil
+	} else if b, isBool := val.(bool); isBool {
+		return b, nil
+	}
+
+	return false, fmt.Errorf("could not get boolean value of %v", val)
+}
+
 func memoryAvailable() string {
 	return `which jq
 if [[ $? -eq 0 ]]; then

node/node_test.go

@@ -26,6 +26,11 @@ func testNode(t *testing.T, when spec.G, it spec.S) {
 		f               *test.BuildFactory
 		stubNodeFixture = filepath.Join("testdata", "stub-node.tar.gz")
 	)
+	var testPriorityMerge = func(planA, planB, expected buildpackplan.Plan) {
+		output, err := node.PriorityPlanMerge(planA, planB)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(output).To(Equal(expected))
+	}
 
 	it.Before(func() {
 		RegisterTestingT(t)
@@ -186,4 +191,105 @@ export MEMORY_AVAILABLE
 			})
 		})
 	})
+
+	when("PriorityPlanMerge", func() {
+		var (
+			planA, planB, expected buildpackplan.Plan
+		)
+
+		when("version key is empty for both", func() {
+			it("leaves the version empty and merges metadata", func() {
+				planA := createNodeBuildPlan("", buildpackplan.Metadata{"key": "1"})
+				planB := createNodeBuildPlan("", buildpackplan.Metadata{"key": "2"})
+				expected := createNodeBuildPlan("", buildpackplan.Metadata{"key": "1,2"})
+
+				testPriorityMerge(planA, planB, expected)
+			})
+		})
+
+		when("version key is empty for one", func() {
+			it("picks the other version and merges metadata", func() {
+				planA := createNodeBuildPlan("", buildpackplan.Metadata{"key": "1"})
+				planB := createNodeBuildPlan("1", buildpackplan.Metadata{"key": "2"})
+				expected := createNodeBuildPlan("1", buildpackplan.Metadata{"key": "1,2"})
+
+				testPriorityMerge(planA, planB, expected)
+			})
+		})
+
+		when("both have versions and VersionSource key is unset for both", func() {
+			it("should pick latest version of the two", func() {
+				planA := createNodeBuildPlan("1.0", buildpackplan.Metadata{})
+				planB := createNodeBuildPlan("2.0", buildpackplan.Metadata{})
+				expected := createNodeBuildPlan("2.0", buildpackplan.Metadata{})
+				testPriorityMerge(planA, planB, expected)
+				testPriorityMerge(planB, planA, expected)
+
+				planA = createNodeBuildPlan("1.0", buildpackplan.Metadata{node.VersionSource: ""})
+				planB = createNodeBuildPlan("2.0", buildpackplan.Metadata{node.VersionSource: ""})
+				expected = createNodeBuildPlan("2.0", buildpackplan.Metadata{node.VersionSource: ""})
+				testPriorityMerge(planA, planB, expected)
+				testPriorityMerge(planB, planA, expected)
+			})
+
+		})
+
+		when("both have versions and VersionSource key is empty for one", func() {
+			it.Before(func() {
+				planA = createNodeBuildPlan("2.0", buildpackplan.Metadata{node.VersionSource: ""})
+				planB = createNodeBuildPlan("1.0", buildpackplan.Metadata{node.VersionSource: "package.json"})
+				expected = createNodeBuildPlan("1.0", buildpackplan.Metadata{node.VersionSource: "package.json"})
+			})
+			it("picks the version and source from the second input", func() {
+				testPriorityMerge(planA, planB, expected)
+			})
+
+			it("picks the version and source from the first input", func() {
+				testPriorityMerge(planB, planA, expected)
+			})
+		})
+
+		when("different priority versions", func() {
+			it.Before(func() {
+				planA = createNodeBuildPlan("2.0", buildpackplan.Metadata{node.VersionSource: "package.json"})
+				planB = createNodeBuildPlan("1.0", buildpackplan.Metadata{node.VersionSource: "buildpack.yml"})
+				expected = createNodeBuildPlan("1.0", buildpackplan.Metadata{node.VersionSource: "buildpack.yml"})
+			})
+
+			it("picks the version and source from the second input", func() {
+				testPriorityMerge(planA, planB, expected)
+			})
+
+			it("picks the version and source from the first input", func() {
+				testPriorityMerge(planB, planA, expected)
+			})
+		})
+
+		when("they are the same priority", func() {
+			it("picks the higher version", func() {
+				planA := createNodeBuildPlan("2.0", buildpackplan.Metadata{node.VersionSource: "buildpack.yml"})
+				planB := createNodeBuildPlan("1.0", buildpackplan.Metadata{node.VersionSource: "buildpack.yml"})
+				expected := createNodeBuildPlan("2.0", buildpackplan.Metadata{node.VersionSource: "buildpack.yml"})
+				testPriorityMerge(planA, planB, expected)
+				testPriorityMerge(planB, planA, expected)
+			})
+		})
+
+		when("different build and launch metadata are set", func() {
+			it("does an or-map of each key", func() {
+				planA := createNodeBuildPlan("", buildpackplan.Metadata{"build": true})
+				planB := createNodeBuildPlan("", buildpackplan.Metadata{"launch": "true", "build": false})
+				expected := createNodeBuildPlan("", buildpackplan.Metadata{"build": true, "launch": true})
+				testPriorityMerge(planA, planB, expected)
+			})
+		})
+	})
+}
+
+func createNodeBuildPlan(version string, metadata buildpackplan.Metadata) buildpackplan.Plan {
+	return buildpackplan.Plan{
+		Name:     node.Dependency,
+		Version:  version,
+		Metadata: metadata,
+	}
 }