implement no-limit and max for memory

Author: scott-the-programmer

minikube/generator/schema_builder.go

@@ -58,7 +58,7 @@ var updateFields = []string{
 var schemaOverrides map[string]SchemaOverride = map[string]SchemaOverride{
 	"memory": {
 		Default:          "4g",
-		Description:      "Amount of RAM to allocate to Kubernetes (format: <number>[<unit>(case-insensitive)], where unit = b, k, kb, m, mb, g or gb)",
+		Description:      "Amount of RAM to allocate to Kubernetes (format: <number>[<unit>], where unit = b, k, m or g). Use \"max\" to use the maximum amount of memory. Use \"no-limit\" to not specify a limit (Docker/Podman only))",
 		Type:             String,
 		StateFunc:        "state_utils.ResourceSizeConverter()",
 		ValidateDiagFunc: "state_utils.ResourceSizeValidator()",
@@ -72,8 +72,8 @@ var schemaOverrides map[string]SchemaOverride = map[string]SchemaOverride{
 	},
 	"cpus": {
 		Default:     "2",
-		Description: "Amount of CPUs to allocate to Kubernetes",
-		Type:        Int,
+		Description: "Number of CPUs allocated to Kubernetes. Use \"max\" to use the maximum number of CPUs. Use \"no-limit\" to not specify a limit (Docker/Podman only)",
+		Type:        String,
 	},
 	// Customize the description to be the fullset of drivers
 	"driver": {

minikube/lib/memory.go

@@ -0,0 +1,32 @@
+package lib
+
+import (
+	"k8s.io/minikube/pkg/minikube/machine"
+)
+
+
+var NoLimit = "no-limit"
+var Max = "max"
+
+// MemoryInfo holds system and container memory information
+type MemoryInfo struct {
+	SystemMemory    int
+}
+
+// GetMemoryLimits returns the amount of memory allocated to the system and container
+// The return values are in MiB
+func GetMemoryLimit() (*MemoryInfo, error) {
+	info, _, memErr, _ := machine.LocalHostInfo()
+
+	if memErr != nil {
+		return nil, memErr
+	}
+
+	// Subtract 1gb for overhead
+	memInfo := &MemoryInfo{
+		SystemMemory:    int(info.Memory) - 1024,
+	}
+
+	return memInfo, nil
+}
+

minikube/resource_cluster.go

@@ -271,7 +271,7 @@ func initialiseMinikubeClient(d *schema.ResourceData, m interface{}) (lib.Cluste
 	}
 
 	memoryStr := d.Get("memory").(string)
-	memoryMb, err := pkgutil.CalculateSizeInMB(memoryStr)
+	memoryMb, err := state_utils.GetMemory(memoryStr);
 	if err != nil {
 		return nil, err
 	}

minikube/state_utils/memory.go

@@ -0,0 +1,38 @@
+package state_utils
+
+import (
+	"github.com/scott-the-programmer/terraform-provider-minikube/minikube/lib"
+	pkgutil "k8s.io/minikube/pkg/util"
+)
+
+func GetMemory(memoryStr string) (int, error) {
+	var memoryMb int
+	var err error
+	if memoryStr == lib.Max {
+		memoryInfo, err := lib.GetMemoryLimit()
+		if err != nil {
+			return 0, err
+		}
+
+		memoryMb = memoryInfo.SystemMemory
+	} else if memoryStr == lib.NoLimit {
+		memoryMb = 0
+	} else {
+		err = ResourceSizeValidatorImpl(memoryStr)
+		if err != nil {
+			return 0, err
+		}
+
+		memoryStr, err = ResourceSizeConverterImpl(memoryStr)
+		if err != nil {
+			return 0, err
+		}
+
+		memoryMb, err = pkgutil.CalculateSizeInMB(memoryStr)
+		if err != nil {
+			return 0, err
+		}
+	}
+
+	return memoryMb, err
+}

minikube/state_utils/resource_size.go

@@ -13,31 +13,46 @@ import (
 
 func ResourceSizeConverter() schema.SchemaStateFunc {
 	return func(val interface{}) string {
-		size, ok := val.(string)
-		if !ok {
-			panic(errors.New("resource size is not a string"))
-		}
-		sizeMb, err := pkgutil.CalculateSizeInMB(size)
+		result, err := ResourceSizeConverterImpl(val)
 		if err != nil {
-			panic(errors.New("invalid resource size value"))
+			panic(err)
 		}
+		return result
+	}
+}
 
-		return strconv.Itoa(sizeMb) + "mb"
+func ResourceSizeConverterImpl(val interface{}) (string, error) {
+	size, ok := val.(string)
+	if !ok {
+		return "", errors.New("resource size is not a string")
 	}
+	sizeMb, err := pkgutil.CalculateSizeInMB(size)
+	if err != nil {
+		return "", errors.New("invalid resource size value")
+	}
+
+	return strconv.Itoa(sizeMb) + "mb", nil
 }
 
 func ResourceSizeValidator() schema.SchemaValidateDiagFunc {
 	return schema.SchemaValidateDiagFunc(func(val interface{}, path cty.Path) diag.Diagnostics {
-		size, ok := val.(string)
-		if !ok {
-			diag := diag.FromErr(errors.New("resource size is not a string"))
-			return diag
-		}
-		_, err := pkgutil.CalculateSizeInMB(size)
+		err := ResourceSizeValidatorImpl(val)
 		if err != nil {
-			diag := diag.FromErr(errors.New("invalid resource size value"))
-			return diag
+			return diag.FromErr(err)
 		}
 		return nil
+
 	})
 }
+
+func ResourceSizeValidatorImpl(val interface{}) error {
+	size, ok := val.(string)
+	if !ok {
+		return errors.New("resource size is not a string")
+	}
+	_, err := pkgutil.CalculateSizeInMB(size)
+	if err != nil {
+		return errors.New("invalid resource size value")
+	}
+	return nil
+}