More minor fixes

pkg/apis/provisioning/v1alpha5/limits.go

@@ -15,57 +15,29 @@ limitations under the License.
 package v1alpha5
 
 import (
-	"context"
 	"fmt"
 
 	v1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/api/resource"
 )
 
-const (
-	// CPU limit, in cores. (500m = .5 cores)
-	ResourceLimitsCPU v1.ResourceName = "cpu"
-	// Memory limit, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
-	ResourceLimitsMemory v1.ResourceName = "memory"
-)
-
-var DefaultCPULimits *resource.Quantity = resource.NewScaledQuantity(100, 0)
-var DefaultMemoryLimits *resource.Quantity = resource.NewScaledQuantity(400, resource.Giga)
-
 // Limits define bounds on the resources being provisioned by Karpenter
 type Limits struct {
 	// Resources contains all the allocatable resources that Karpenter supports for limiting.
 	Resources v1.ResourceList `json:"resources,omitempty"`
 }
 
-func (l *Limits) Default(ctx context.Context) {
-	if l.Resources == nil {
-		l.Resources = v1.ResourceList{
-			ResourceLimitsCPU:    *DefaultCPULimits,
-			ResourceLimitsMemory: *DefaultMemoryLimits,
-		}
-		return
-	}
-	if _, ok := l.Resources[ResourceLimitsCPU]; !ok {
-		l.Resources[ResourceLimitsCPU] = *DefaultCPULimits
-	}
-	if _, ok := l.Resources[ResourceLimitsMemory]; !ok {
-		l.Resources[ResourceLimitsMemory] = *DefaultMemoryLimits
-	}
-}
-
-func (p *Provisioner) HasExceededResources() (bool, error) {
+func (p *Provisioner) HasExceededResources() error {
 	var currentResource = p.Status.Resources
 	var currentLimits = p.Spec.Limits.Resources
 
-	var CPUUsage = currentResource[ResourceLimitsCPU]
-	if CPUUsage.Cmp(currentLimits[ResourceLimitsCPU]) >= 0 {
-		return true, fmt.Errorf("cpu limits exceeded")
-	}
-
-	var MemoryUsage = currentResource[ResourceLimitsCPU]
-	if MemoryUsage.Cmp(currentLimits[ResourceLimitsCPU]) >= 0 {
-		return true, fmt.Errorf("memory limits exceeded")
+	for resourceName, usage := range currentResource {
+		fmt.Printf("resourceName %v resourceUsage %v\n", resourceName, usage)
+		if limit, ok := currentLimits[resourceName]; ok {
+			fmt.Printf("limitName %v limitUsage %v\n", resourceName, limit)
+			if usage.Cmp(limit) >= 0 {
+				return fmt.Errorf("%v limits exceeded", resourceName)
+			}
+		}
 	}
-	return false, nil
+	return nil
 }

pkg/apis/provisioning/v1alpha5/provisioner_defaults.go

@@ -21,7 +21,6 @@ import (
 // SetDefaults for the provisioner
 func (p *Provisioner) SetDefaults(ctx context.Context) {
 	p.Spec.Constraints.Default(ctx)
-	p.Spec.Limits.Default(ctx)
 }
 
 // Default the constraints

pkg/apis/provisioning/v1alpha5/provisioner_validation.go

@@ -42,6 +42,7 @@ func (s *ProvisionerSpec) validate(ctx context.Context) (errs *apis.FieldError)
 	return errs.Also(
 		s.validateTTLSecondsUntilExpired(),
 		s.validateTTLSecondsAfterEmpty(),
+		s.validateResourceLimits(),
 		s.Constraints.Validate(ctx),
 	)
 }
@@ -52,13 +53,21 @@ func (s *ProvisionerSpec) validateTTLSecondsUntilExpired() (errs *apis.FieldErro
 	}
 	return errs
 }
+
 func (s *ProvisionerSpec) validateTTLSecondsAfterEmpty() (errs *apis.FieldError) {
 	if ptr.Int64Value(s.TTLSecondsAfterEmpty) < 0 {
 		return errs.Also(apis.ErrInvalidValue("cannot be negative", "ttlSecondsAfterEmpty"))
 	}
 	return errs
 }
 
+func (s *ProvisionerSpec) validateResourceLimits() (errs *apis.FieldError) {
+	if s.Limits.Resources == nil || len(s.Limits.Resources) == 0 {
+		return errs.Also(apis.ErrInvalidValue("cannot be empty", "limits"))
+	}
+	return errs
+}
+
 // Validate the constraints
 func (c *Constraints) Validate(ctx context.Context) (errs *apis.FieldError) {
 	return errs.Also(

pkg/controllers/counter/controller.go

@@ -16,13 +16,11 @@ package counter
 import (
 	"context"
 	"fmt"
-	"time"
 
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/api/resource"
 	"k8s.io/apimachinery/pkg/types"
-	"knative.dev/pkg/logging"
 	controllerruntime "sigs.k8s.io/controller-runtime"
 
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -53,7 +51,6 @@ func NewController(ctx context.Context, kubeClient client.Client) *Controller {
 
 // Reconcile a control loop for the resource
 func (c *Controller) Reconcile(ctx context.Context, req reconcile.Request) (reconcile.Result, error) {
-	logging.FromContext(ctx).Infof("Updating resource counts on provisioner")
 	// Retrieve the provisioner
 	provisioner := &v1alpha5.Provisioner{}
 	if err := c.kubeClient.Get(ctx, req.NamespacedName, provisioner); err != nil {
@@ -75,8 +72,7 @@ func (c *Controller) Reconcile(ctx context.Context, req reconcile.Request) (reco
 		return reconcile.Result{}, fmt.Errorf("failed to persist changes to %s, %w", req.NamespacedName, err)
 	}
 
-	// Refresh the reconciler state values every 5 minutes irrespective of node events
-	return reconcile.Result{RequeueAfter: 5 * time.Minute}, nil
+	return reconcile.Result{}, nil
 }
 
 func (c *Controller) resourceCountsFor(ctx context.Context, provisionerName string) (v1.ResourceList, error) {
@@ -93,8 +89,8 @@ func (c *Controller) resourceCountsFor(ctx context.Context, provisionerName stri
 		memory.Add(*node.Status.Capacity.Memory())
 	}
 	return v1.ResourceList{
-		v1alpha5.ResourceLimitsCPU:    *cpu,
-		v1alpha5.ResourceLimitsMemory: *memory,
+		v1.ResourceCPU:    *cpu,
+		v1.ResourceMemory: *memory,
 	}, nil
 
 }
@@ -116,8 +112,7 @@ func (c *Controller) Register(ctx context.Context, m manager.Manager) error {
 			&source.Kind{Type: &v1.Node{}},
 			handler.EnqueueRequestsFromMapFunc(func(o client.Object) (requests []reconcile.Request) {
 				if provisionerName, ok := o.GetLabels()[v1alpha5.ProvisionerNameLabelKey]; ok {
-					requests = append(requests, reconcile.Request{NamespacedName: types.NamespacedName{Name: provisionerName}})
-					return requests
+					return []reconcile.Request{{NamespacedName: types.NamespacedName{Name: provisionerName}}}
 				}
 				return nil
 			}),

pkg/controllers/provisioning/launcher.go

@@ -30,6 +30,7 @@ import (
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
 	corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
 	"k8s.io/client-go/util/workqueue"
 	"knative.dev/pkg/logging"
@@ -49,9 +50,13 @@ func (l *Launcher) Launch(ctx context.Context, provisioner *v1alpha5.Provisioner
 
 	// Pack and bind pods
 	errs := make([]error, len(schedules))
+	provisioner, err := l.updateState(ctx, provisioner)
+	if err != nil {
+		return fmt.Errorf("unable to determine status of provisioner")
+	}
 	workqueue.ParallelizeUntil(ctx, len(schedules), len(schedules), func(index int) {
 		for _, packing := range l.Packer.Pack(ctx, schedules[index], instanceTypes) {
-			if ok, err := provisioner.HasExceededResources(); ok {
+			if err := provisioner.HasExceededResources(); err != nil {
 				errs[index] = multierr.Append(errs[index], err)
 				continue
 			}
@@ -116,6 +121,14 @@ func (l *Launcher) bind(ctx context.Context, node *v1.Node, pods []*v1.Pod) (err
 	return nil
 }
 
+func (l *Launcher) updateState(ctx context.Context, provisioner *v1alpha5.Provisioner) (*v1alpha5.Provisioner, error) {
+	provisionerCopy := &v1alpha5.Provisioner{}
+	if err := l.KubeClient.Get(ctx, types.NamespacedName{Name: provisioner.Name, Namespace: provisioner.Namespace}, provisionerCopy); err != nil {
+		return nil, err
+	}
+	return provisionerCopy, nil
+}
+
 var bindTimeHistogram = prometheus.NewHistogram(
 	prometheus.HistogramOpts{
 		Namespace: metrics.Namespace,