Move nodeResources to cache file

Author: norbertcyran

cluster-autoscaler/resourcequotas/cache.go

@@ -17,27 +17,30 @@ limitations under the License.
 package resourcequotas
 
 import (
+	"fmt"
+
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider"
 	cacontext "k8s.io/autoscaler/cluster-autoscaler/context"
+	"k8s.io/autoscaler/cluster-autoscaler/core/utils"
 	"k8s.io/autoscaler/cluster-autoscaler/processors/customresources"
 )
 
 type nodeCache struct {
-	crp    customresources.CustomResourcesProcessor
-	deltas map[string]resourceList
+	crp       customresources.CustomResourcesProcessor
+	resources map[string]resourceList
 }
 
 func newNodeCache(crp customresources.CustomResourcesProcessor) *nodeCache {
 	return &nodeCache{
-		crp:    crp,
-		deltas: make(map[string]resourceList),
+		crp:       crp,
+		resources: make(map[string]resourceList),
 	}
 }
 
 func (nc *nodeCache) nodeResources(autoscalingCtx *cacontext.AutoscalingContext, node *corev1.Node, nodeGroup cloudprovider.NodeGroup) (resourceList, error) {
 	if nodeGroup != nil {
-		if delta, ok := nc.deltas[nodeGroup.Id()]; ok {
+		if delta, ok := nc.resources[nodeGroup.Id()]; ok {
 			return delta, nil
 		}
 	}
@@ -46,7 +49,29 @@ func (nc *nodeCache) nodeResources(autoscalingCtx *cacontext.AutoscalingContext,
 		return nil, err
 	}
 	if nodeGroup != nil {
-		nc.deltas[nodeGroup.Id()] = delta
+		nc.resources[nodeGroup.Id()] = delta
 	}
 	return delta, nil
 }
+
+// nodeResources calculates the amount of resources that a node contains.
+func nodeResources(autoscalingCtx *cacontext.AutoscalingContext, crp customresources.CustomResourcesProcessor, node *corev1.Node, nodeGroup cloudprovider.NodeGroup) (resourceList, error) {
+	// TODO: storage?
+	nodeCPU, nodeMemory := utils.GetNodeCoresAndMemory(node)
+	nodeResources := resourceList{
+		string(corev1.ResourceCPU):    nodeCPU,
+		string(corev1.ResourceMemory): nodeMemory,
+		ResourceNodes:                 1,
+	}
+
+	resourceTargets, err := crp.GetNodeResourceTargets(autoscalingCtx, node, nodeGroup)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get custom resources: %w", err)
+	}
+
+	for _, resourceTarget := range resourceTargets {
+		nodeResources[resourceTarget.ResourceType] = resourceTarget.ResourceCount
+	}
+
+	return nodeResources, nil
+}

cluster-autoscaler/resourcequotas/cache_test.go

@@ -48,7 +48,7 @@ func (m *mockCustomResourcesProcessor) CleanUp() {
 	return
 }
 
-func TestNodeCacheNodeResources(t *testing.T) {
+func TestNodeCache(t *testing.T) {
 	node := test.BuildTestNode("n1", 1000, 2000)
 	autoscalingCtx := &context.AutoscalingContext{}
 	ng1 := cptest.NewTestNodeGroup("ng1", 1, 10, 1, true, false, "n1-template", nil, nil)
@@ -117,3 +117,65 @@ func TestNodeCacheNodeResources(t *testing.T) {
 		})
 	}
 }
+
+func TestNodeResources(t *testing.T) {
+	testCases := []struct {
+		name      string
+		node      *apiv1.Node
+		crp       customresources.CustomResourcesProcessor
+		wantDelta resourceList
+	}{
+		{
+			name: "node just with CPU and memory",
+			node: test.BuildTestNode("test", 1000, 2048),
+			crp:  &fakeCustomResourcesProcessor{},
+			wantDelta: resourceList{
+				"cpu":    1,
+				"memory": 2048,
+				"nodes":  1,
+			},
+		},
+		{
+			// nodes should not have milliCPUs in the capacity, so we round it up
+			// to the nearest integer.
+			name: "node just with CPU and memory, milli cores rounded up",
+			node: test.BuildTestNode("test", 2500, 4096),
+			crp:  &fakeCustomResourcesProcessor{},
+			wantDelta: resourceList{
+				"cpu":    3,
+				"memory": 4096,
+				"nodes":  1,
+			},
+		},
+		{
+			name: "node with custom resources",
+			node: test.BuildTestNode("test", 1000, 2048),
+			crp: &fakeCustomResourcesProcessor{NodeResourceTargets: func(node *apiv1.Node) []customresources.CustomResourceTarget {
+				return []customresources.CustomResourceTarget{
+					{
+						ResourceType:  "gpu",
+						ResourceCount: 1,
+					},
+				}
+			}},
+			wantDelta: resourceList{
+				"cpu":    1,
+				"memory": 2048,
+				"gpu":    1,
+				"nodes":  1,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx := &context.AutoscalingContext{}
+			delta, err := nodeResources(ctx, tc.crp, tc.node, nil)
+			if err != nil {
+				t.Errorf("nodeResources: unexpected error: %v", err)
+			}
+			if diff := cmp.Diff(tc.wantDelta, delta); diff != "" {
+				t.Errorf("delta mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}

cluster-autoscaler/resourcequotas/tracker.go

@@ -17,13 +17,9 @@ limitations under the License.
 package resourcequotas
 
 import (
-	"fmt"
-
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider"
 	"k8s.io/autoscaler/cluster-autoscaler/context"
-	"k8s.io/autoscaler/cluster-autoscaler/core/utils"
-	"k8s.io/autoscaler/cluster-autoscaler/processors/customresources"
 )
 
 const (
@@ -173,25 +169,3 @@ type ExceededQuota struct {
 	ID                string
 	ExceededResources []string
 }
-
-// nodeResources calculates the amount of resources that will be used from the cluster when creating a node.
-func nodeResources(autoscalingCtx *context.AutoscalingContext, crp customresources.CustomResourcesProcessor, node *corev1.Node, nodeGroup cloudprovider.NodeGroup) (resourceList, error) {
-	// TODO: storage?
-	nodeCPU, nodeMemory := utils.GetNodeCoresAndMemory(node)
-	nodeResources := resourceList{
-		string(corev1.ResourceCPU):    nodeCPU,
-		string(corev1.ResourceMemory): nodeMemory,
-		ResourceNodes:                 1,
-	}
-
-	resourceTargets, err := crp.GetNodeResourceTargets(autoscalingCtx, node, nodeGroup)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get custom resources: %w", err)
-	}
-
-	for _, resourceTarget := range resourceTargets {
-		nodeResources[resourceTarget.ResourceType] = resourceTarget.ResourceCount
-	}
-
-	return nodeResources, nil
-}

cluster-autoscaler/resourcequotas/tracker_test.go

@@ -312,65 +312,3 @@ func TestApplyDelta(t *testing.T) {
 		})
 	}
 }
-
-func TestNodeResources(t *testing.T) {
-	testCases := []struct {
-		name      string
-		node      *apiv1.Node
-		crp       customresources.CustomResourcesProcessor
-		wantDelta resourceList
-	}{
-		{
-			name: "node just with CPU and memory",
-			node: test.BuildTestNode("test", 1000, 2048),
-			crp:  &fakeCustomResourcesProcessor{},
-			wantDelta: resourceList{
-				"cpu":    1,
-				"memory": 2048,
-				"nodes":  1,
-			},
-		},
-		{
-			// nodes should not have milliCPUs in the capacity, so we round it up
-			// to the nearest integer.
-			name: "node just with CPU and memory, milli cores rounded up",
-			node: test.BuildTestNode("test", 2500, 4096),
-			crp:  &fakeCustomResourcesProcessor{},
-			wantDelta: resourceList{
-				"cpu":    3,
-				"memory": 4096,
-				"nodes":  1,
-			},
-		},
-		{
-			name: "node with custom resources",
-			node: test.BuildTestNode("test", 1000, 2048),
-			crp: &fakeCustomResourcesProcessor{NodeResourceTargets: func(node *apiv1.Node) []customresources.CustomResourceTarget {
-				return []customresources.CustomResourceTarget{
-					{
-						ResourceType:  "gpu",
-						ResourceCount: 1,
-					},
-				}
-			}},
-			wantDelta: resourceList{
-				"cpu":    1,
-				"memory": 2048,
-				"gpu":    1,
-				"nodes":  1,
-			},
-		},
-	}
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			ctx := &context.AutoscalingContext{}
-			delta, err := nodeResources(ctx, tc.crp, tc.node, nil)
-			if err != nil {
-				t.Errorf("nodeResources: unexpected error: %v", err)
-			}
-			if diff := cmp.Diff(tc.wantDelta, delta); diff != "" {
-				t.Errorf("delta mismatch (-want +got):\n%s", diff)
-			}
-		})
-	}
-}