memory manager: improve the reserved memory validation logic

We will have two layers of the validation.

- the first part of the validation logic will be implemented under the
`ValidateKubeletConfiguration` method
- the second one that requires knowledge about machine topology and
node allocatable resources will be implemented under the memory manager.

Signed-off-by: Artyom Lukianov <alukiano@redhat.com>

pkg/kubelet/apis/config/validation/BUILD

@@ -11,14 +11,17 @@ go_library(
     srcs = [
         "validation.go",
         "validation_others.go",
+        "validation_reserved_memory.go",
         "validation_windows.go",
     ],
     importpath = "k8s.io/kubernetes/pkg/kubelet/apis/config/validation",
     deps = [
+        "//pkg/apis/core/v1/helper:go_default_library",
         "//pkg/features:go_default_library",
         "//pkg/kubelet/apis/config:go_default_library",
         "//pkg/kubelet/cm/cpuset:go_default_library",
         "//pkg/kubelet/types:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/errors:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/validation:go_default_library",
@@ -43,10 +46,15 @@ filegroup(
 
 go_test(
     name = "go_default_test",
-    srcs = ["validation_test.go"],
+    srcs = [
+        "validation_reserved_memory_test.go",
+        "validation_test.go",
+    ],
     embed = [":go_default_library"],
     deps = [
         "//pkg/kubelet/apis/config:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/api/resource:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/errors:go_default_library",
     ],

pkg/kubelet/apis/config/validation/validation.go

@@ -193,6 +193,8 @@ func ValidateKubeletConfiguration(kc *kubeletconfig.KubeletConfiguration) error
 		}
 	}
 
+	allErrors = append(allErrors, validateReservedMemoryConfiguration(kc)...)
+
 	if err := validateKubeletOSConfiguration(kc); err != nil {
 		allErrors = append(allErrors, err)
 	}

pkg/kubelet/apis/config/validation/validation_reserved_memory.go

@@ -0,0 +1,64 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package validation
+
+import (
+	"fmt"
+
+	v1 "k8s.io/api/core/v1"
+	corev1helper "k8s.io/kubernetes/pkg/apis/core/v1/helper"
+	kubeletconfig "k8s.io/kubernetes/pkg/kubelet/apis/config"
+)
+
+// validateReservedMemory validates the reserved memory configuration and returns an error if it is invalid.
+func validateReservedMemoryConfiguration(kc *kubeletconfig.KubeletConfiguration) []error {
+	if len(kc.ReservedMemory) == 0 {
+		return nil
+	}
+
+	var errors []error
+
+	numaTypeDuplicates := map[int32]map[v1.ResourceName]bool{}
+	for _, reservedMemory := range kc.ReservedMemory {
+		numaNode := reservedMemory.NumaNode
+		if _, ok := numaTypeDuplicates[numaNode]; !ok {
+			numaTypeDuplicates[numaNode] = map[v1.ResourceName]bool{}
+		}
+
+		for resourceName, q := range reservedMemory.Limits {
+			if !reservedMemorySupportedLimit(resourceName) {
+				errors = append(errors, fmt.Errorf("the limit type %q for NUMA node %d is not supported, only %v is accepted", resourceName, numaNode, []v1.ResourceName{v1.ResourceMemory, v1.ResourceHugePagesPrefix + "<HugePageSize>"}))
+			}
+
+			// validates that the limit has non-zero value
+			if q.IsZero() {
+				errors = append(errors, fmt.Errorf("reserved memory may not be zero for NUMA node %d and resource %q", numaNode, resourceName))
+			}
+
+			// validates that no duplication for NUMA node and limit type occurred
+			if _, ok := numaTypeDuplicates[numaNode][resourceName]; ok {
+				errors = append(errors, fmt.Errorf("the reserved memory has a duplicate value for NUMA node %d and resource %q", numaNode, resourceName))
+			}
+			numaTypeDuplicates[numaNode][resourceName] = true
+		}
+	}
+	return errors
+}
+
+func reservedMemorySupportedLimit(resourceName v1.ResourceName) bool {
+	return corev1helper.IsHugePageResourceName(resourceName) || resourceName == v1.ResourceMemory
+}

pkg/kubelet/apis/config/validation/validation_reserved_memory_test.go

@@ -0,0 +1,120 @@
+/*
+Copyright 2020 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package validation
+
+import (
+	"fmt"
+	"testing"
+
+	v1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	kubeletconfig "k8s.io/kubernetes/pkg/kubelet/apis/config"
+)
+
+func TestValidateReservedMemoryConfiguration(t *testing.T) {
+	testCases := []struct {
+		description          string
+		kubeletConfiguration *kubeletconfig.KubeletConfiguration
+		expectedError        error
+	}{
+		{
+			description:          "The kubelet configuration does not have reserved memory parameter",
+			kubeletConfiguration: &kubeletconfig.KubeletConfiguration{},
+			expectedError:        nil,
+		},
+		{
+			description: "The kubelet configuration has valid reserved memory parameter",
+			kubeletConfiguration: &kubeletconfig.KubeletConfiguration{
+				ReservedMemory: []kubeletconfig.MemoryReservation{
+					{
+						NumaNode: 0,
+						Limits: v1.ResourceList{
+							v1.ResourceMemory: *resource.NewQuantity(128, resource.DecimalSI),
+						},
+					},
+				},
+			},
+			expectedError: nil,
+		},
+		{
+			description: "The reserved memory has duplications for the NUMA node and limit type",
+			kubeletConfiguration: &kubeletconfig.KubeletConfiguration{
+				ReservedMemory: []kubeletconfig.MemoryReservation{
+					{
+						NumaNode: 0,
+						Limits: v1.ResourceList{
+							v1.ResourceMemory: *resource.NewQuantity(128, resource.DecimalSI),
+						},
+					},
+					{
+						NumaNode: 0,
+						Limits: v1.ResourceList{
+							v1.ResourceMemory: *resource.NewQuantity(64, resource.DecimalSI),
+						},
+					},
+				},
+			},
+			expectedError: fmt.Errorf("the reserved memory has a duplicate value for NUMA node %d and resource %q", 0, v1.ResourceMemory),
+		},
+		{
+			description: "The reserved memory has unsupported limit type",
+			kubeletConfiguration: &kubeletconfig.KubeletConfiguration{
+				ReservedMemory: []kubeletconfig.MemoryReservation{
+					{
+						NumaNode: 0,
+						Limits: v1.ResourceList{
+							"blabla": *resource.NewQuantity(128, resource.DecimalSI),
+						},
+					},
+				},
+			},
+			expectedError: fmt.Errorf("the limit type %q for NUMA node %d is not supported, only [memory hugepages-<HugePageSize>] is accepted", "blabla", 0),
+		},
+		{
+			description: "The reserved memory has limit type with zero value",
+			kubeletConfiguration: &kubeletconfig.KubeletConfiguration{
+				ReservedMemory: []kubeletconfig.MemoryReservation{
+					{
+						NumaNode: 0,
+						Limits: v1.ResourceList{
+							v1.ResourceMemory: *resource.NewQuantity(0, resource.DecimalSI),
+						},
+					},
+				},
+			},
+			expectedError: fmt.Errorf("reserved memory may not be zero for NUMA node %d and resource %q", 0, v1.ResourceMemory),
+		},
+	}
+
+	for _, testCase := range testCases {
+		errors := validateReservedMemoryConfiguration(testCase.kubeletConfiguration)
+
+		if len(errors) != 0 && testCase.expectedError == nil {
+			t.Errorf("expected errors %v, got %v", errors, testCase.expectedError)
+		}
+
+		if testCase.expectedError != nil {
+			if len(errors) == 0 {
+				t.Errorf("expected error %v, got %v", testCase.expectedError, errors)
+			}
+
+			if errors[0].Error() != testCase.expectedError.Error() {
+				t.Errorf("expected error %v, got %v", testCase.expectedError, errors[0])
+			}
+		}
+	}
+}