move annotation to nodeclaim

pkg/apis/v1/labels.go

@@ -44,13 +44,13 @@ const (
 
 // Karpenter specific annotations
 const (
-	DoNotDisruptAnnotationKey             = apis.Group + "/do-not-disrupt"
-	ProviderCompatabilityAnnotationKey    = apis.CompatabilityGroup + "/provider"
-	ManagedByAnnotationKey                = apis.Group + "/managed-by"
-	NodePoolHashAnnotationKey             = apis.Group + "/nodepool-hash"
-	NodePoolHashVersionAnnotationKey      = apis.Group + "/nodepool-hash-version"
-	KubeletCompatabilityAnnotationKey     = apis.CompatabilityGroup + "/v1beta1-kubelet-conversion"
-	NodeTerminationTimestampAnnotationKey = apis.Group + "/node-termination-timestamp"
+	DoNotDisruptAnnotationKey                  = apis.Group + "/do-not-disrupt"
+	ProviderCompatabilityAnnotationKey         = apis.CompatabilityGroup + "/provider"
+	ManagedByAnnotationKey                     = apis.Group + "/managed-by"
+	NodePoolHashAnnotationKey                  = apis.Group + "/nodepool-hash"
+	NodePoolHashVersionAnnotationKey           = apis.Group + "/nodepool-hash-version"
+	KubeletCompatabilityAnnotationKey          = apis.CompatabilityGroup + "/v1beta1-kubelet-conversion"
+	NodeClaimTerminationTimestampAnnotationKey = apis.Group + "/nodeclaim-termination-timestamp"
 )
 
 // Karpenter specific finalizers

pkg/controllers/node/termination/controller.go

@@ -81,11 +81,16 @@ func (c *Controller) finalize(ctx context.Context, node *corev1.Node) (reconcile
 	if !controllerutil.ContainsFinalizer(node, v1.TerminationFinalizer) {
 		return reconcile.Result{}, nil
 	}
-	if err := c.deleteAllNodeClaims(ctx, node); err != nil {
+	nodeClaims, err := nodeutils.GetNodeClaims(ctx, node, c.kubeClient)
+	if err != nil {
+		return reconcile.Result{}, fmt.Errorf("listing nodeclaims, %w", err)
+	}
+
+	if err := c.deleteAllNodeClaims(ctx, nodeClaims...); err != nil {
 		return reconcile.Result{}, fmt.Errorf("deleting nodeclaims, %w", err)
 	}
 
-	nodeTerminationTime, err := c.nodeTerminationTime(node)
+	nodeTerminationTime, err := c.nodeTerminationTime(nodeClaims...)
 	if err != nil {
 		return reconcile.Result{}, err
 	}
@@ -113,7 +118,7 @@ func (c *Controller) finalize(ctx context.Context, node *corev1.Node) (reconcile
 
 		return reconcile.Result{RequeueAfter: 1 * time.Second}, nil
 	}
-	nodeClaims, err := nodeutils.GetNodeClaims(ctx, node, c.kubeClient)
+	nodeClaims, err = nodeutils.GetNodeClaims(ctx, node, c.kubeClient)
 	if err != nil {
 		return reconcile.Result{}, fmt.Errorf("deleting nodeclaims, %w", err)
 	}
@@ -140,11 +145,7 @@ func (c *Controller) finalize(ctx context.Context, node *corev1.Node) (reconcile
 	return reconcile.Result{}, nil
 }
 
-func (c *Controller) deleteAllNodeClaims(ctx context.Context, node *corev1.Node) error {
-	nodeClaims, err := nodeutils.GetNodeClaims(ctx, node, c.kubeClient)
-	if err != nil {
-		return err
-	}
+func (c *Controller) deleteAllNodeClaims(ctx context.Context, nodeClaims ...*v1.NodeClaim) error {
 	for _, nodeClaim := range nodeClaims {
 		// If we still get the NodeClaim, but it's already marked as terminating, we don't need to call Delete again
 		if nodeClaim.DeletionTimestamp.IsZero() {
@@ -175,14 +176,17 @@ func (c *Controller) removeFinalizer(ctx context.Context, n *corev1.Node) error
 	return nil
 }
 
-func (c *Controller) nodeTerminationTime(node *corev1.Node) (*time.Time, error) {
-	expirationTimeString, exists := node.ObjectMeta.Annotations[v1.NodeTerminationTimestampAnnotationKey]
+func (c *Controller) nodeTerminationTime(nodeClaims ...*v1.NodeClaim) (*time.Time, error) {
+	if len(nodeClaims) == 0 {
+		return nil, nil
+	}
+	expirationTimeString, exists := nodeClaims[0].ObjectMeta.Annotations[v1.NodeClaimTerminationTimestampAnnotationKey]
 	if !exists {
 		return nil, nil
 	}
 	expirationTime, err := time.Parse(time.RFC3339, expirationTimeString)
 	if err != nil {
-		return nil, fmt.Errorf("parsing %s annotation, %w", v1.NodeTerminationTimestampAnnotationKey, err)
+		return nil, fmt.Errorf("parsing %s annotation, %w", v1.NodeClaimTerminationTimestampAnnotationKey, err)
 	}
 	return &expirationTime, nil
 }

pkg/controllers/node/termination/suite_test.go

@@ -711,8 +711,8 @@ var _ = Describe("Termination", func() {
 		})
 		It("should preemptively delete pods to satisfy their terminationGracePeriodSeconds", func() {
 			nodeClaim.Spec.TerminationGracePeriod = &metav1.Duration{Duration: time.Second * 300}
-			node.Annotations = map[string]string{
-				v1.NodeTerminationTimestampAnnotationKey: time.Now().Add(nodeClaim.Spec.TerminationGracePeriod.Duration).Format(time.RFC3339),
+			nodeClaim.Annotations = map[string]string{
+				v1.NodeClaimTerminationTimestampAnnotationKey: time.Now().Add(nodeClaim.Spec.TerminationGracePeriod.Duration).Format(time.RFC3339),
 			}
 			pod := test.Pod(test.PodOptions{
 				NodeName: node.Name,
@@ -734,8 +734,8 @@ var _ = Describe("Termination", func() {
 		})
 		It("should only delete pods when their terminationGracePeriodSeconds is less than the the node's remaining terminationGracePeriod", func() {
 			nodeClaim.Spec.TerminationGracePeriod = &metav1.Duration{Duration: time.Second * 300}
-			node.Annotations = map[string]string{
-				v1.NodeTerminationTimestampAnnotationKey: time.Now().Add(nodeClaim.Spec.TerminationGracePeriod.Duration).Format(time.RFC3339),
+			nodeClaim.Annotations = map[string]string{
+				v1.NodeClaimTerminationTimestampAnnotationKey: time.Now().Add(nodeClaim.Spec.TerminationGracePeriod.Duration).Format(time.RFC3339),
 			}
 			pod := test.Pod(test.PodOptions{
 				NodeName: node.Name,

pkg/controllers/nodeclaim/termination/controller.go

@@ -151,7 +151,7 @@ func (c *Controller) finalize(ctx context.Context, nodeClaim *v1.NodeClaim) (rec
 
 func (c *Controller) ensureTerminationGracePeriodTerminationTimeAnnotation(ctx context.Context, node *corev1.Node, nodeClaim *v1.NodeClaim) error {
 	// if the expiration annotation is already set, we don't need to do anything
-	if _, exists := node.ObjectMeta.Annotations[v1.NodeTerminationTimestampAnnotationKey]; exists {
+	if _, exists := nodeClaim.ObjectMeta.Annotations[v1.NodeClaimTerminationTimestampAnnotationKey]; exists {
 		return nil
 	}
 
@@ -168,12 +168,12 @@ func (c *Controller) ensureTerminationGracePeriodTerminationTimeAnnotation(ctx c
 
 func (c *Controller) annotateTerminationGracePeriodTerminationTime(ctx context.Context, node *corev1.Node, nodeClaim *v1.NodeClaim, terminationTime string) error {
 	stored := node.DeepCopy()
-	node.ObjectMeta.Annotations = lo.Assign(node.ObjectMeta.Annotations, map[string]string{v1.NodeTerminationTimestampAnnotationKey: terminationTime})
+	nodeClaim.ObjectMeta.Annotations = lo.Assign(nodeClaim.ObjectMeta.Annotations, map[string]string{v1.NodeClaimTerminationTimestampAnnotationKey: terminationTime})
 
 	if err := c.kubeClient.Patch(ctx, node, client.MergeFrom(stored)); err != nil {
 		return client.IgnoreNotFound(fmt.Errorf("patching nodeclaim, %w", err))
 	}
-	log.FromContext(ctx).WithValues(v1.NodeTerminationTimestampAnnotationKey, terminationTime).Info("annotated node")
+	log.FromContext(ctx).WithValues(v1.NodeClaimTerminationTimestampAnnotationKey, terminationTime).Info("annotated node")
 	c.recorder.Publish(terminatorevents.NodeTerminationGracePeriodExpiring(node, terminationTime))
 	c.recorder.Publish(terminatorevents.NodeClaimTerminationGracePeriodExpiring(nodeClaim, terminationTime))
 

pkg/controllers/nodeclaim/termination/suite_test.go

@@ -284,8 +284,10 @@ var _ = Describe("Termination", func() {
 
 		Expect(env.Client.Delete(ctx, nodeClaim)).To(Succeed())
 		ExpectObjectReconciled(ctx, env.Client, nodeClaimTerminationController, nodeClaim) // triggers the node deletion
-		node = ExpectExists(ctx, env.Client, node)
-		Expect(node.ObjectMeta.Annotations).To(BeNil())
+		ExpectExists(ctx, env.Client, node)
+		nodeClaim = ExpectExists(ctx, env.Client, nodeClaim)
+
+		Expect(nodeClaim.ObjectMeta.Annotations).To(BeNil())
 	})
 	It("should annotate the node if the NodeClaim has a terminationGracePeriod", func() {
 		nodeClaim.Spec.TerminationGracePeriod = &metav1.Duration{Duration: time.Second * 300}
@@ -301,9 +303,10 @@ var _ = Describe("Termination", func() {
 
 		Expect(env.Client.Delete(ctx, nodeClaim)).To(Succeed())
 		ExpectObjectReconciled(ctx, env.Client, nodeClaimTerminationController, nodeClaim) // triggers the node deletion
-		node = ExpectExists(ctx, env.Client, node)
+		ExpectExists(ctx, env.Client, node)
+		nodeClaim = ExpectExists(ctx, env.Client, nodeClaim)
 
-		_, annotationExists := node.ObjectMeta.Annotations[v1.NodeTerminationTimestampAnnotationKey]
+		_, annotationExists := nodeClaim.ObjectMeta.Annotations[v1.NodeClaimTerminationTimestampAnnotationKey]
 		Expect(annotationExists).To(BeTrue())
 	})
 	It("should not change the annotation if the NodeClaim has a terminationGracePeriod and the annotation already exists", func() {
@@ -316,17 +319,18 @@ var _ = Describe("Termination", func() {
 		Expect(err).ToNot(HaveOccurred())
 
 		node := test.NodeClaimLinkedNode(nodeClaim)
-		node.ObjectMeta.Annotations = map[string]string{
-			v1.NodeTerminationTimestampAnnotationKey: "2024-04-01T12:00:00-05:00",
+		nodeClaim.ObjectMeta.Annotations = map[string]string{
+			v1.NodeClaimTerminationTimestampAnnotationKey: "2024-04-01T12:00:00-05:00",
 		}
 		ExpectApplied(ctx, env.Client, node)
 
 		Expect(env.Client.Delete(ctx, nodeClaim)).To(Succeed())
 		ExpectObjectReconciled(ctx, env.Client, nodeClaimTerminationController, nodeClaim) // triggers the node deletion
-		node = ExpectExists(ctx, env.Client, node)
+		ExpectExists(ctx, env.Client, node)
+		nodeClaim = ExpectExists(ctx, env.Client, nodeClaim)
 
-		Expect(node.ObjectMeta.Annotations).To(Equal(map[string]string{
-			v1.NodeTerminationTimestampAnnotationKey: "2024-04-01T12:00:00-05:00",
+		Expect(nodeClaim.ObjectMeta.Annotations).To(Equal(map[string]string{
+			v1.NodeClaimTerminationTimestampAnnotationKey: "2024-04-01T12:00:00-05:00",
 		}))
 	})
 })