Report an error if -totMemory omitted, or specifies less than 1K.

Previously, if the -totMemory flag was omitted the memory calculator would
allocate the minimum of the size ranges supplied in -memorySizes. However, if
some memory types had a zero lower-bound (the default), the allocation would
be zero. This is never a valid memory option.

This change makes an omitted -totMemory flag, or a flag that specifies less
than one kilobyte, an error, resulting in a non-zero exit code (and a message
on stderr).

Some code in the memory calculator is removed.

[#94311618]

Author: Steve Powell

flags/validate_flags.go

@@ -54,7 +54,7 @@ var (
 )
 
 // Validate flags passed on command line; exit(1) if invalid; exit(2) if help printed
-func ValidateFlags() (memSize memory.MemSize, weights map[string]float64, sizes map[string]memory.Range, memIsSpecified bool) {
+func ValidateFlags() (memSize memory.MemSize, weights map[string]float64, sizes map[string]memory.Range) {
 
 	flag.Parse() // exit on error
 
@@ -63,24 +63,29 @@ func ValidateFlags() (memSize memory.MemSize, weights map[string]float64, sizes
 		os.Exit(2)
 	}
 
-	// validation routines exit on error
-	memSize, memIsSpecified = validateTotMemory(*totMemory)
+	// validation routines will not return on error
+	memSize = validateTotMemory(*totMemory)
 	weights = validateWeights(*memoryWeights)
 	sizes = validateSizes(*memorySizes)
 
-	return memSize, weights, sizes, memIsSpecified
+	return memSize, weights, sizes
 }
 
-func validateTotMemory(mem string) (value memory.MemSize, isSpecified bool) {
+func validateTotMemory(mem string) memory.MemSize {
 	if mem == "" {
-		return memory.MEMSIZE_ZERO, false
+		fmt.Fprintf(os.Stderr, "-%s must be specified", totalFlag)
+		os.Exit(1)
 	}
 	ms, err := memory.NewMemSizeFromString(mem)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error in -%s flag: %s", totalFlag, err)
 		os.Exit(1)
 	}
-	return ms, true
+	if ms.LessThan(memory.MemSize(1024)) {
+		fmt.Fprintf(os.Stderr, "Total memory (-%s flag) is less than 1K", totalFlag)
+		os.Exit(1)
+	}
+	return ms
 }
 
 func validateWeights(weights string) map[string]float64 {

integration/main_test.go

@@ -61,6 +61,33 @@ var _ = Describe("java-buildpack-memory-calculator executable", func() {
 		Ω(string(se)).Should(ContainSubstring("Weight must be positive in -memoryWeights flag; clause 'heap:-2'"), "stderr incorrect for "+badFlags[0])
 	})
 
+	It("executes with error when no total memory is supplied", func() {
+		badFlags :=
+			[]string{
+				"-memoryWeights=heap:5,stack:1,permgen:3,native:1",
+				"-memorySizes=stack:2m..,heap:30m..400m,permgen:10m..12m",
+			}
+		so, se, err := runOutAndErr(badFlags...)
+		Ω(err).Should(HaveOccurred(), "no -totMemory flag")
+
+		Ω(string(so)).Should(BeEmpty(), "stdout not empty when no -totMemory flag")
+		Ω(string(se)).Should(ContainSubstring("-totMemory must be specified"), "stderr incorrect when no -totMemory flag")
+	})
+
+	It("executes with error when too little total memory is supplied", func() {
+		badFlags :=
+			[]string{
+				"-totMemory=1023b",
+				"-memoryWeights=heap:5,stack:1,permgen:3,native:1",
+				"-memorySizes=stack:2m..,heap:30m..400m,permgen:10m..12m",
+			}
+		so, se, err := runOutAndErr(badFlags...)
+		Ω(err).Should(HaveOccurred(), badFlags[0])
+
+		Ω(string(so)).Should(BeEmpty(), "stdout not empty for "+badFlags[0])
+		Ω(string(se)).Should(ContainSubstring("Total memory (-totMemory flag) is less than 1K"), "stderr incorrect for "+badFlags[0])
+	})
+
 	Context("with valid parameters", func() {
 		var (
 			totMemFlag, weightsFlag, sizesFlag string
@@ -79,25 +106,6 @@ var _ = Describe("java-buildpack-memory-calculator executable", func() {
 			sOut, sErr, cmdErr = runOutAndErr(goodFlags...)
 		})
 
-		Context("when no total memory is supplied", func() {
-			BeforeEach(func() {
-				totMemFlag = ""
-				sizesFlag = "-memorySizes=stack:2m..,heap:30m..400m,permgen:10m..12m"
-			})
-
-			It("allocates the minima", func() {
-				Ω(cmdErr).ShouldNot(HaveOccurred(), "exit status")
-				Ω(string(sErr)).Should(Equal(""), "stderr")
-				Ω(strings.Split(string(sOut), " ")).Should(ConsistOf(
-					"-Xmx30M",
-					"-Xms30M",
-					"-Xss2M",
-					"-XX:MaxPermSize=10M",
-					"-XX:PermSize=10M",
-				), "stdout")
-			})
-		})
-
 		Context("using nothing but total memory parameter", func() {
 			BeforeEach(func() {
 				totMemFlag = "-totMemory=4g"

main.go

@@ -33,7 +33,7 @@ const (
 func main() {
 
 	// validateFlags() will exit on error
-	memSize, weights, sizes, memSizeSpecified := flags.ValidateFlags()
+	memSize, weights, sizes := flags.ValidateFlags()
 
 	switchFuns := switches.AllJreSwitchFuns
 
@@ -43,16 +43,12 @@ func main() {
 		os.Exit(1)
 	}
 
-	if memSizeSpecified {
-		if err = allocator.Balance(memSize); err != nil {
-			fmt.Fprintf(os.Stderr, "Cannot balance memory: %s", err)
-			os.Exit(1)
-		}
-		if warnings := allocator.GetWarnings(); len(warnings) != 0 {
-			fmt.Fprintln(os.Stderr, strings.Join(warnings, "\n"))
-		}
-	} else {
-		allocator.SetLowerBounds()
+	if err = allocator.Balance(memSize); err != nil {
+		fmt.Fprintf(os.Stderr, "Cannot balance memory: %s", err)
+		os.Exit(1)
+	}
+	if warnings := allocator.GetWarnings(); len(warnings) != 0 {
+		fmt.Fprintln(os.Stderr, strings.Join(warnings, "\n"))
 	}
 
 	switches := allocator.Switches(switchFuns)

memory/allocator.go

@@ -25,7 +25,6 @@ import (
 
 type Allocator interface {
 	Balance(memLimit MemSize) error  // Balance allocations to buckets within memory limit
-	SetLowerBounds()                 // Allocate smallest memories allowed
 	Switches(switches.Funs) []string // Get selected memory switches from current allocations
 	GetWarnings() []string           // Get warnings (if balancing succeeded)
 }
@@ -56,6 +55,10 @@ const (
 // Balance memory between buckets, adjusting stack units, observing
 // constraints, and detecting memory wastage and default proximity.
 func (a *allocator) Balance(memLimit MemSize) error {
+	if memLimit.LessThan(MemSize(kILO)) {
+		return fmt.Errorf("Too little memory to allocate: %s", memLimit)
+	}
+
 	// adjust stack bucket, if it exists
 	stackBucket, estNumThreads := a.normaliseStack(memLimit)
 
@@ -73,12 +76,6 @@ func (a *allocator) Balance(memLimit MemSize) error {
 	return nil
 }
 
-func (a *allocator) SetLowerBounds() {
-	for _, b := range a.buckets {
-		b.SetSize(b.Range().Floor())
-	}
-}
-
 func (a *allocator) Switches(sfs switches.Funs) []string {
 	var strs = make([]string, 0, 10)
 	for s, b := range a.buckets {

memory/allocator_test.go

@@ -17,7 +17,6 @@ package memory_test
 
 import (
 	"github.com/cloudfoundry/java-buildpack-memory-calculator/memory"
-	"github.com/cloudfoundry/java-buildpack-memory-calculator/memory/switches"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -59,7 +58,6 @@ var _ = Describe("Allocator", func() {
 	Context("constructor", func() {
 
 		Context("with good parameters", func() {
-
 			BeforeEach(func() {
 				sizes = strmap{
 					"stack":   "2m",
@@ -87,26 +85,6 @@ var _ = Describe("Allocator", func() {
 					"Bucket{name: native, size: <nil>, range: 0.., weight: 1}",
 				))
 			})
-
-			It("sets lower bounds and reports switches correctly", func() {
-				a.SetLowerBounds()
-
-				Ω(memory.GetBuckets(a)).Should(ConsistOf(
-					"Bucket{name: stack, size: 2M, range: 2M..2M, weight: 1}",
-					"Bucket{name: heap, size: 30M, range: 30M.., weight: 5}",
-					"Bucket{name: permgen, size: 10M, range: 10M..10M, weight: 3}",
-					"Bucket{name: native, size: 0, range: 0.., weight: 1}",
-				))
-
-				sws := a.Switches(switches.AllJreSwitchFuns)
-				Ω(sws).Should(ConsistOf(
-					"-Xmx30M",
-					"-Xms30M",
-					"-XX:MaxPermSize=10M",
-					"-XX:PermSize=10M",
-					"-Xss2M",
-				)) // heap, permgen, stack
-			})
 		})
 	})
 
@@ -136,6 +114,15 @@ var _ = Describe("Allocator", func() {
 				It("fails", func() {})
 			})
 
+			Context("with no memory and no buckets", func() {
+				BeforeEach(func() {
+					sizes = strmap{"heap": "0.."}
+					weights = floatmap{}
+					memLimit = memory.MEMSIZE_ZERO
+				})
+				It("fails", func() {})
+			})
+
 			Context("with not enough memory and one bucket", func() {
 				BeforeEach(func() {
 					sizes = strmap{"heap": "64m.."}
@@ -182,17 +169,6 @@ var _ = Describe("Allocator", func() {
 				})
 			})
 
-			Context("with no memory and no buckets", func() {
-				BeforeEach(func() {
-					sizes = strmap{"heap": "0.."}
-					weights = floatmap{}
-					memLimit = memory.MEMSIZE_ZERO
-				})
-				It("results in no buckets", func() {
-					Ω(memory.GetBuckets(a)).Should(BeEmpty())
-				})
-			})
-
 			Context("with single bucket to 'balance'", func() {
 
 				BeforeEach(func() {