Add support for multiple resource limits

Author: norbertcyran

cluster-autoscaler/cloudprovider/resource_limiter.go

@@ -99,10 +99,6 @@ func (r *ResourceLimiter) AppliesTo(node *apiv1.Node) bool {
 	return true
 }
 
-func (r *ResourceLimiter) MaxLimits() map[string]int64 {
+func (r *ResourceLimiter) Limits() map[string]int64 {
 	return r.maxLimits
 }
-
-func (r *ResourceLimiter) MinLimits() map[string]int64 {
-	return r.minLimits
-}

cluster-autoscaler/resourcelimits/factory.go

@@ -0,0 +1,69 @@
+package resourcequotas
+
+import (
+	"fmt"
+
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/autoscaler/cluster-autoscaler/context"
+	"k8s.io/autoscaler/cluster-autoscaler/processors/customresources"
+)
+
+// TrackerFactory builds trackers.
+type TrackerFactory struct {
+	crp             customresources.CustomResourcesProcessor
+	quotaProviders  []Provider
+	usageCalculator *usageCalculator
+}
+
+type TrackerOptions struct {
+	CRP        customresources.CustomResourcesProcessor
+	Providers  []Provider
+	NodeFilter NodeFilter
+}
+
+// NewTrackerFactory creates a new TrackerFactory.
+func NewTrackerFactory(opts TrackerOptions) *TrackerFactory {
+	uc := newUsageCalculator(opts.CRP, opts.NodeFilter)
+	return &TrackerFactory{
+		crp:             opts.CRP,
+		quotaProviders:  opts.Providers,
+		usageCalculator: uc,
+	}
+}
+
+// NewQuotasTracker builds a new Tracker.
+func (f *TrackerFactory) NewQuotasTracker(ctx *context.AutoscalingContext, nodes []*corev1.Node) (*Tracker, error) {
+	quotas, err := f.quotas()
+	if err != nil {
+		return nil, err
+	}
+	usages, err := f.usageCalculator.calculateUsages(ctx, nodes, quotas)
+	if err != nil {
+		return nil, err
+	}
+	limitsLeft := make(map[string]resourceList)
+	for _, rq := range quotas {
+		limitsLeft[rq.ID()] = make(resourceList)
+		limits := rq.Limits()
+		for resourceType, limit := range limits {
+			usage := usages[rq.ID()][resourceType]
+			limitsLeft[rq.ID()][resourceType] = max(0, limit-usage)
+		}
+	}
+	tracker := newTracker(f.crp, quotas, limitsLeft)
+	return tracker, nil
+}
+
+func (f *TrackerFactory) quotas() ([]Quota, error) {
+	var quotas []Quota
+	for _, provider := range f.quotaProviders {
+		provQuotas, err := provider.Quotas()
+		if err != nil {
+			return nil, fmt.Errorf("failed to get quotas from provider: %w", err)
+		}
+		for _, rq := range provQuotas {
+			quotas = append(quotas, rq)
+		}
+	}
+	return quotas, nil
+}

cluster-autoscaler/resourcelimits/provider.go

@@ -1,4 +1,4 @@
-package resourcelimits
+package resourcequotas
 
 import (
 	"testing"
@@ -209,90 +209,10 @@ func TestMaxLimitsTracker(t *testing.T) {
 			}
 			factory := NewTrackerFactory(TrackerOptions{
 				CRP:        crp,
-				Providers:  []Provider{NewCloudLimitersProvider(cloudProvider)},
+				Providers:  []Provider{NewCloudQuotasProvider(cloudProvider)},
 				NodeFilter: tc.nodeFilter,
 			})
-			tracker, err := factory.NewMaxLimitsTracker(ctx, tc.nodes)
-			if err != nil {
-				t.Errorf("failed to create tracker: %v", err)
-			}
-			var ng cloudprovider.NodeGroup
-			result, err := tracker.CheckDelta(ctx, ng, tc.newNode, tc.nodeDelta)
-			if err != nil {
-				t.Errorf("failed to check delta: %v", err)
-			}
-			if diff := cmp.Diff(tc.wantResult, result, cmpopts.SortSlices(func(a, b string) bool { return a < b }), cmpopts.EquateEmpty()); diff != "" {
-				t.Errorf("CheckDelta() mismatch (-want +got):\n%s", diff)
-			}
-		})
-	}
-}
-
-func TestMinLimitsTracker(t *testing.T) {
-	testCases := []struct {
-		name       string
-		crp        customresources.CustomResourcesProcessor
-		nodeFilter NodeFilter
-		nodes      []*apiv1.Node
-		limits     map[string]int64
-		newNode    *apiv1.Node
-		nodeDelta  int
-		wantResult *CheckDeltaResult
-	}{
-		{
-			name: "default config allowed operation",
-			nodes: []*apiv1.Node{
-				test.BuildTestNode("n1", 1000, 2*units.GiB),
-				test.BuildTestNode("n2", 2000, 4*units.GiB),
-				test.BuildTestNode("n3", 3000, 8*units.GiB),
-			},
-			limits: map[string]int64{
-				"cpu":    1,
-				"memory": 2 * units.GiB,
-			},
-			newNode:   test.BuildTestNode("n1", 1000, 2*units.GiB),
-			nodeDelta: 1,
-			wantResult: &CheckDeltaResult{
-				AllowedDelta: 1,
-			},
-		},
-		{
-			name: "default config exceeded operation",
-			nodes: []*apiv1.Node{
-				test.BuildTestNode("n1", 1000, 2*units.GiB),
-				test.BuildTestNode("n2", 2000, 4*units.GiB),
-				test.BuildTestNode("n3", 3000, 8*units.GiB),
-			},
-			limits: map[string]int64{
-				"cpu":    6,
-				"memory": 10 * units.GiB,
-			},
-			newNode:   test.BuildTestNode("n3", 3000, 8*units.GiB),
-			nodeDelta: 1,
-			wantResult: &CheckDeltaResult{
-				AllowedDelta: 0,
-				ExceededResources: map[string][]string{
-					"cluster-wide": {"cpu", "memory"},
-				},
-			},
-		},
-	}
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			cloudProvider := cptest.NewTestCloudProviderBuilder().Build()
-			resourceLimiter := cloudprovider.NewResourceLimiter(tc.limits, nil)
-			cloudProvider.SetResourceLimiter(resourceLimiter)
-			ctx := &context.AutoscalingContext{CloudProvider: cloudProvider}
-			crp := tc.crp
-			if crp == nil {
-				crp = &fakeCustomResourcesProcessor{}
-			}
-			factory := NewTrackerFactory(TrackerOptions{
-				CRP:        crp,
-				Providers:  []Provider{NewCloudLimitersProvider(cloudProvider)},
-				NodeFilter: tc.nodeFilter,
-			})
-			tracker, err := factory.NewMinLimitsTracker(ctx, tc.nodes)
+			tracker, err := factory.NewQuotasTracker(ctx, tc.nodes)
 			if err != nil {
 				t.Errorf("failed to create tracker: %v", err)
 			}

cluster-autoscaler/resourcelimits/provider_test.go

@@ -0,0 +1,26 @@
+package resourcequotas
+
+import (
+	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider"
+)
+
+type Provider interface {
+	Quotas() ([]Quota, error)
+}
+type CloudQuotasProvider struct {
+	cloudProvider cloudprovider.CloudProvider
+}
+
+func (p *CloudQuotasProvider) Quotas() ([]Quota, error) {
+	rl, err := p.cloudProvider.GetResourceLimiter()
+	if err != nil {
+		return nil, err
+	}
+	return []Quota{rl}, nil
+}
+
+func NewCloudQuotasProvider(cloudProvider cloudprovider.CloudProvider) *CloudQuotasProvider {
+	return &CloudQuotasProvider{
+		cloudProvider: cloudProvider,
+	}
+}