chore: remove v1alpha5 from cluster state (#654)

pkg/controllers/controllers.go

@@ -61,9 +61,7 @@ func NewControllers(
 		informer.NewDaemonSetController(kubeClient, cluster),
 		informer.NewNodeController(kubeClient, cluster),
 		informer.NewPodController(kubeClient, cluster),
-		informer.NewProvisionerController(kubeClient, cluster),
 		informer.NewNodePoolController(kubeClient, cluster),
-		informer.NewMachineController(kubeClient, cluster),
 		informer.NewNodeClaimController(kubeClient, cluster),
 		termination.NewController(kubeClient, cloudProvider, terminator.NewTerminator(clock, kubeClient, evictionQueue), recorder),
 		metricspod.NewController(kubeClient),

pkg/controllers/nodepool/counter/suite_test.go

@@ -41,11 +41,9 @@ import (
 	"github.com/aws/karpenter-core/pkg/test"
 )
 
-var provisionerInformerController controller.Controller
 var nodePoolController controller.Controller
 var nodePoolInformerController controller.Controller
 var nodeClaimController controller.Controller
-var machineController controller.Controller
 var nodeController controller.Controller
 var ctx context.Context
 var env *test.Environment
@@ -66,9 +64,7 @@ var _ = BeforeSuite(func() {
 	fakeClock = clock.NewFakeClock(time.Now())
 	cluster = state.NewCluster(fakeClock, env.Client, cloudProvider)
 	nodeClaimController = informer.NewNodeClaimController(env.Client, cluster)
-	machineController = informer.NewMachineController(env.Client, cluster)
 	nodeController = informer.NewNodeController(env.Client, cluster)
-	provisionerInformerController = informer.NewProvisionerController(env.Client, cluster)
 	nodePoolInformerController = informer.NewNodePoolController(env.Client, cluster)
 	nodePoolController = counter.NewNodePoolController(env.Client, cluster)
 })

pkg/controllers/provisioning/scheduling/suite_test.go

@@ -67,7 +67,6 @@ var fakeClock *clock.FakeClock
 var cluster *state.Cluster
 var cloudProvider *fake.CloudProvider
 var nodeStateController controller.Controller
-var machineStateController controller.Controller
 var nodeClaimStateController controller.Controller
 var podStateController controller.Controller
 
@@ -88,13 +87,10 @@ var _ = BeforeSuite(func() {
 	cloudProvider.InstanceTypes = instanceTypes
 	fakeClock = clock.NewFakeClock(time.Now())
 	cluster = state.NewCluster(fakeClock, env.Client, cloudProvider)
-	machineStateController = informer.NewMachineController(env.Client, cluster)
 	nodeStateController = informer.NewNodeController(env.Client, cluster)
-	machineStateController = informer.NewMachineController(env.Client, cluster)
 	nodeClaimStateController = informer.NewNodeClaimController(env.Client, cluster)
 	podStateController = informer.NewPodController(env.Client, cluster)
 	prov = provisioning.NewProvisioner(env.Client, env.KubernetesInterface.CoreV1(), events.NewRecorder(&record.FakeRecorder{}), cloudProvider, cluster)
-
 })
 
 var _ = AfterSuite(func() {

pkg/controllers/state/cluster.go

@@ -80,18 +80,13 @@ func NewCluster(clk clock.Clock, client client.Client, cp cloudprovider.CloudPro
 	}
 }
 
-// Synced validates that the Machines and the Nodes that are stored in the apiserver
+// Synced validates that the NodeClaims and the Nodes that are stored in the apiserver
 // have the same representation in the cluster state. This is to ensure that our view
 // of the cluster is as close to correct as it can be when we begin to perform operations
 // utilizing the cluster state as our source of truth
 //
 //nolint:gocyclo
 func (c *Cluster) Synced(ctx context.Context) bool {
-	machineList := &v1alpha5.MachineList{}
-	if err := c.kubeClient.List(ctx, machineList); err != nil {
-		logging.FromContext(ctx).Errorf("checking cluster state sync, %v", err)
-		return false
-	}
 	nodeClaimList := &v1beta1.NodeClaimList{}
 	if err := c.kubeClient.List(ctx, nodeClaimList); err != nil {
 		logging.FromContext(ctx).Errorf("checking cluster state sync, %v", err)
@@ -103,29 +98,16 @@ func (c *Cluster) Synced(ctx context.Context) bool {
 		return false
 	}
 	c.mu.RLock()
-	stateMachineNames := sets.New[string]()
 	stateNodeClaimNames := sets.New[string]()
 	for k := range c.nodeClaimKeyToProviderID {
-		if k.IsMachine {
-			stateMachineNames.Insert(k.Name)
-		} else {
-			stateNodeClaimNames.Insert(k.Name)
-		}
+		stateNodeClaimNames.Insert(k.Name)
 	}
 	stateNodeNames := sets.New(lo.Keys(c.nodeNameToProviderID)...)
 	c.mu.RUnlock()
 
-	machineNames := sets.New[string]()
-	for _, machine := range machineList.Items {
-		// If the machine hasn't resolved its provider id, then it hasn't resolved its status
-		if machine.Status.ProviderID == "" {
-			return false
-		}
-		machineNames.Insert(machine.Name)
-	}
 	nodeClaimNames := sets.New[string]()
 	for _, nodeClaim := range nodeClaimList.Items {
-		// If the machine hasn't resolved its provider id, then it hasn't resolved its status
+		// If the nodeClaim hasn't resolved its provider id, then it hasn't resolved its status
 		if nodeClaim.Status.ProviderID == "" {
 			return false
 		}
@@ -138,9 +120,8 @@ func (c *Cluster) Synced(ctx context.Context) bool {
 	// The names tracked in-memory should at least have all the data that is in the api-server
 	// This doesn't ensure that the two states are exactly aligned (we could still not be tracking a node
 	// that exists in the cluster state but not in the apiserver) but it ensures that we have a state
-	// representation for every node/machine that exists on the apiserver
-	return stateMachineNames.IsSuperset(machineNames) &&
-		stateNodeClaimNames.IsSuperset(nodeClaimNames) &&
+	// representation for every node/nodeClaim that exists on the apiserver
+	return stateNodeClaimNames.IsSuperset(nodeClaimNames) &&
 		stateNodeNames.IsSuperset(nodeNames)
 }