Merge pull request #52 from helen-frank/helen-frank/dev-general

chore: fix vswitch status

Author: jwcesign

cmd/controller/main.go

@@ -59,6 +59,9 @@ func main() {
 			op.InstanceProvider,
 			op.InstanceTypeProvider,
 			op.PricingProvider,
+			op.VSwitchProvider,
+			op.SecurityGroupProvider,
+			op.LaunchTemplateProvider,
 		)...).
 		Start(ctx, cloudProvider)
 }

config/components/crds/karpenter.k8s.alicloud_ecsnodeclasses.yaml

@@ -257,7 +257,7 @@ spec:
                       additionalProperties:
                         type: string
                       description: |-
-                        Tags is a map of key/value tags used to select subnets
+                        Tags is a map of key/value tags used to select vSwitches
                         Specifying '*' for a value selects all values for a given tag key.
                       maxProperties: 20
                       type: object

go.mod

@@ -113,7 +113,7 @@ require (
 	k8s.io/cloud-provider v0.30.3 // indirect
 	k8s.io/component-base v0.30.3 // indirect
 	k8s.io/csi-translation-lib v0.30.3 // indirect
-	k8s.io/klog v1.0.0 // indirect
+	k8s.io/klog v1.0.0
 	k8s.io/klog/v2 v2.130.1
 	k8s.io/kube-openapi v0.0.0-20240228011516-70dd3763d340 // indirect
 	knative.dev/pkg v0.0.0-20231010144348-ca8c009405dd

pkg/apis/v1alpha1/ecsnodeclass.go

@@ -88,7 +88,7 @@ type VSwitchSelectorTerm struct {
 // SecurityGroupSelectorTerm defines selection logic for a security group used by Karpenter to launch nodes.
 // If multiple fields are used for selection, the requirements are ANDed.
 type SecurityGroupSelectorTerm struct {
-	// Tags is a map of key/value tags used to select subnets
+	// Tags is a map of key/value tags used to select vSwitches
 	// Specifying '*' for a value selects all values for a given tag key.
 	// +kubebuilder:validation:XValidation:message="empty tag keys aren't supported",rule="self.all(k, k != '')"
 	// +kubebuilder:validation:MaxProperties:=20

pkg/apis/v1alpha1/ecsnodeclass_status.go

@@ -22,7 +22,7 @@ import (
 )
 
 const (
-	ConditionTypeVSwitchsReady       = "VSwitchsReady"
+	ConditionTypeVSwitchesReady      = "VSwitchesReady"
 	ConditionTypeSecurityGroupsReady = "SecurityGroupsReady"
 	ConditionTypeInstanceRAMReady    = "InstanceRAMReady"
 )
@@ -81,7 +81,7 @@ type ECSNodeClassStatus struct {
 
 func (in *ECSNodeClass) StatusConditions() status.ConditionSet {
 	return status.NewReadyConditions(
-		ConditionTypeVSwitchsReady,
+		ConditionTypeVSwitchesReady,
 		ConditionTypeSecurityGroupsReady,
 		ConditionTypeInstanceRAMReady,
 	).For(in)

pkg/cloudprovider/drift.go

@@ -49,11 +49,11 @@ func (c *CloudProvider) isNodeClassDrifted(ctx context.Context, nodeClaim *karpv
 	if err != nil {
 		return "", fmt.Errorf("calculating securitygroup drift, %w", err)
 	}
-	subnetDrifted, err := c.isVSwitchDrifted(instance, nodeClass)
+	vSwitchDrifted, err := c.isVSwitchDrifted(instance, nodeClass)
 	if err != nil {
-		return "", fmt.Errorf("calculating subnet drift, %w", err)
+		return "", fmt.Errorf("calculating vSwitch drift, %w", err)
 	}
-	drifted := lo.FindOrElse([]cloudprovider.DriftReason{securitygroupDrifted, subnetDrifted}, "", func(i cloudprovider.DriftReason) bool {
+	drifted := lo.FindOrElse([]cloudprovider.DriftReason{securitygroupDrifted, vSwitchDrifted}, "", func(i cloudprovider.DriftReason) bool {
 		return string(i) != ""
 	})
 	return drifted, nil

pkg/controllers/controllers.go

@@ -30,22 +30,29 @@ import (
 	nodeclaimtagging "github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/controllers/nodeclaim/tagging"
 	nodeclasshash "github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/controllers/nodeclass/hash"
 	nodeclaasstatus "github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/controllers/nodeclass/status"
+	nodeclasstermination "github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/controllers/nodeclass/termination"
 	providersinstancetype "github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/controllers/providers/instancetype"
 	controllerspricing "github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/controllers/providers/pricing"
 	"github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/providers/instance"
 	"github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/providers/instancetype"
+	"github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/providers/launchtemplate"
 	"github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/providers/pricing"
+	"github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/providers/securitygroup"
+	"github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/providers/vswitch"
 )
 
 func NewControllers(ctx context.Context, mgr manager.Manager, clk clock.Clock,
 	kubeClient client.Client, recorder events.Recorder,
-	cloudProvider cloudprovider.CloudProvider, instanceProvider instance.Provider,
-	instanceTypeProvider instancetype.Provider,
-	pricingProvider pricing.Provider) []controller.Controller {
+	cloudProvider cloudprovider.CloudProvider,
+	instanceProvider instance.Provider, instanceTypeProvider instancetype.Provider,
+	pricingProvider pricing.Provider,
+	vSwitchProvider vswitch.Provider, securitygroupProvider securitygroup.Provider,
+	launchTemplateProvider launchtemplate.Provider) []controller.Controller {
 
 	controllers := []controller.Controller{
 		nodeclasshash.NewController(kubeClient),
-		nodeclaasstatus.NewController(kubeClient),
+		nodeclaasstatus.NewController(kubeClient, vSwitchProvider, securitygroupProvider),
+		nodeclasstermination.NewController(kubeClient, recorder, launchTemplateProvider),
 		controllerspricing.NewController(pricingProvider),
 		nodeclaimgarbagecollection.NewController(kubeClient, cloudProvider),
 		nodeclaimtagging.NewController(kubeClient, instanceProvider),

pkg/controllers/nodeclass/status/controller.go

@@ -20,6 +20,7 @@ import (
 	"context"
 
 	"github.com/awslabs/operatorpkg/reasonable"
+	"go.uber.org/multierr"
 	"k8s.io/apimachinery/pkg/api/equality"
 	"k8s.io/apimachinery/pkg/api/errors"
 	controllerruntime "sigs.k8s.io/controller-runtime"
@@ -29,17 +30,30 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	"sigs.k8s.io/karpenter/pkg/operator/injection"
+	"sigs.k8s.io/karpenter/pkg/utils/result"
 
 	"github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/apis/v1alpha1"
+	"github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/providers/securitygroup"
+	"github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/providers/vswitch"
 )
 
+type nodeClassStatusReconciler interface {
+	Reconcile(context.Context, *v1alpha1.ECSNodeClass) (reconcile.Result, error)
+}
+
 type Controller struct {
 	kubeClient client.Client
+
+	vSwitch       *VSwitch
+	securitygroup *SecurityGroup
 }
 
-func NewController(kubeClient client.Client) *Controller {
+func NewController(kubeClient client.Client, vSwitchProvider vswitch.Provider, securitygroupProvider securitygroup.Provider) *Controller {
 	return &Controller{
 		kubeClient: kubeClient,
+
+		vSwitch:       &VSwitch{vSwitchProvider: vSwitchProvider},
+		securitygroup: &SecurityGroup{securityGroupProvider: securitygroupProvider},
 	}
 }
 
@@ -64,8 +78,17 @@ func (c *Controller) Reconcile(ctx context.Context, nodeClass *v1alpha1.ECSNodeC
 
 	// TODO: implement different conditions setup
 	nodeClass.StatusConditions().SetTrue(v1alpha1.ConditionTypeInstanceRAMReady)
-	nodeClass.StatusConditions().SetTrue(v1alpha1.ConditionTypeSecurityGroupsReady)
-	nodeClass.StatusConditions().SetTrue(v1alpha1.ConditionTypeVSwitchsReady)
+
+	var results []reconcile.Result
+	var errs error
+	for _, reconciler := range []nodeClassStatusReconciler{
+		c.vSwitch,
+		c.securitygroup,
+	} {
+		res, err := reconciler.Reconcile(ctx, nodeClass)
+		errs = multierr.Append(errs, err)
+		results = append(results, res)
+	}
 
 	if !equality.Semantic.DeepEqual(stored, nodeClass) {
 		// We use client.MergeFromWithOptimisticLock because patching a list with a JSON merge patch
@@ -75,11 +98,14 @@ func (c *Controller) Reconcile(ctx context.Context, nodeClass *v1alpha1.ECSNodeC
 			if errors.IsConflict(err) {
 				return reconcile.Result{Requeue: true}, nil
 			}
-			return reconcile.Result{}, client.IgnoreNotFound(err)
+			errs = multierr.Append(errs, client.IgnoreNotFound(err))
 		}
 	}
 
-	return reconcile.Result{}, nil
+	if errs != nil {
+		return reconcile.Result{}, errs
+	}
+	return result.Min(results...), nil
 }
 
 func (c *Controller) Register(_ context.Context, m manager.Manager) error {

pkg/controllers/nodeclass/status/securitygroup.go

@@ -0,0 +1,58 @@
+/*
+Copyright 2024 The CloudPilot AI Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package status
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"time"
+
+	ecsclient "github.com/alibabacloud-go/ecs-20140526/v4/client"
+	"github.com/samber/lo"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+
+	"github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/apis/v1alpha1"
+	"github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/providers/securitygroup"
+)
+
+type SecurityGroup struct {
+	securityGroupProvider securitygroup.Provider
+}
+
+func (sg *SecurityGroup) Reconcile(ctx context.Context, nodeClass *v1alpha1.ECSNodeClass) (reconcile.Result, error) {
+	securityGroups, err := sg.securityGroupProvider.List(ctx, nodeClass)
+	if err != nil {
+		return reconcile.Result{}, fmt.Errorf("getting security groups, %w", err)
+	}
+	if len(securityGroups) == 0 && len(nodeClass.Spec.SecurityGroupSelectorTerms) > 0 {
+		nodeClass.Status.SecurityGroups = nil
+		nodeClass.StatusConditions().SetFalse(v1alpha1.ConditionTypeSecurityGroupsReady, "SecurityGroupsNotFound", "SecurityGroupSelector did not match any SecurityGroups")
+		return reconcile.Result{}, nil
+	}
+	sort.Slice(securityGroups, func(i, j int) bool {
+		return *securityGroups[i].SecurityGroupId < *securityGroups[j].SecurityGroupId
+	})
+	nodeClass.Status.SecurityGroups = lo.Map(securityGroups, func(securityGroup *ecsclient.DescribeSecurityGroupsResponseBodySecurityGroupsSecurityGroup, _ int) v1alpha1.SecurityGroup {
+		return v1alpha1.SecurityGroup{
+			ID:   *securityGroup.SecurityGroupId,
+			Name: *securityGroup.SecurityGroupName,
+		}
+	})
+	nodeClass.StatusConditions().SetTrue(v1alpha1.ConditionTypeSecurityGroupsReady)
+	return reconcile.Result{RequeueAfter: 5 * time.Minute}, nil
+}

pkg/controllers/nodeclass/status/vswitch.go

@@ -0,0 +1,61 @@
+/*
+Copyright 2024 The CloudPilot AI Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package status
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"time"
+
+	vpc "github.com/alibabacloud-go/vpc-20160428/v6/client"
+	"github.com/samber/lo"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+
+	"github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/apis/v1alpha1"
+	"github.com/cloudpilot-ai/karpenter-provider-alicloud/pkg/providers/vswitch"
+)
+
+type VSwitch struct {
+	vSwitchProvider vswitch.Provider
+}
+
+func (v *VSwitch) Reconcile(ctx context.Context, nodeClass *v1alpha1.ECSNodeClass) (reconcile.Result, error) {
+	vSwitches, err := v.vSwitchProvider.List(ctx, nodeClass)
+	if err != nil {
+		return reconcile.Result{}, fmt.Errorf("getting vSwitches, %w", err)
+	}
+	if len(vSwitches) == 0 {
+		nodeClass.Status.VSwitches = nil
+		nodeClass.StatusConditions().SetFalse(v1alpha1.ConditionTypeVSwitchesReady, "vSwitchesNotFound", "VSwitchSelector did not match any VSwitches")
+		return reconcile.Result{}, nil
+	}
+	sort.Slice(vSwitches, func(i, j int) bool {
+		if int(*vSwitches[i].AvailableIpAddressCount) != int(*vSwitches[j].AvailableIpAddressCount) {
+			return int(*vSwitches[i].AvailableIpAddressCount) > int(*vSwitches[j].AvailableIpAddressCount)
+		}
+		return *vSwitches[i].VSwitchId < *vSwitches[j].VSwitchId
+	})
+	nodeClass.Status.VSwitches = lo.Map(vSwitches, func(ecsvSwitch *vpc.DescribeVSwitchesResponseBodyVSwitchesVSwitch, _ int) v1alpha1.VSwitch {
+		return v1alpha1.VSwitch{
+			ID:     *ecsvSwitch.VSwitchId,
+			ZoneID: *ecsvSwitch.ZoneId,
+		}
+	})
+	nodeClass.StatusConditions().SetTrue(v1alpha1.ConditionTypeVSwitchesReady)
+	return reconcile.Result{RequeueAfter: time.Minute}, nil
+}