[feat, breaking] add LMT controller to support tag propagation, remove tag propagation via annotations (#790)

* add LMT controller

* remove local-dev files

* clone tags in lm

* auto-gen role

* address feedback & set status tags only on success

* add e2e test for LMT

* remove redundant comment

---------

Co-authored-by: rpotla <[email protected]>
Co-authored-by: Ashley Dumaine <[email protected]>

Author: 3 people

.gitignore

@@ -10,3 +10,4 @@ release/*
 templates/cluster-template*.yaml
 infrastructure-*-linode/*
 .envrc
+vendor/

api/v1alpha2/linodemachine_types.go

@@ -65,9 +65,7 @@ type LinodeMachineSpec struct {
 	BackupsEnabled bool `json:"backupsEnabled,omitempty"`
 	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="Value is immutable"
 	PrivateIP *bool `json:"privateIP,omitempty"`
-	// Deprecated: spec.tags is deprecated, use metadata.annotations.linode-vm-tags instead.
-	// +kubebuilder:deprecatedversion:warning="spec.tags is deprecated, use metadata.annotations.linode-vm-tags instead"
-	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="Value is immutable"
+	// Tags is a list of tags to apply to the Linode instance.
 	Tags []string `json:"tags,omitempty"`
 	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="Value is immutable"
 	FirewallID int `json:"firewallID,omitempty"`
@@ -225,6 +223,10 @@ type LinodeMachineStatus struct {
 	// Conditions defines current service state of the LinodeMachine.
 	// +optional
 	Conditions []metav1.Condition `json:"conditions,omitempty"`
+
+	// tags are the tags applied to the Linode Machine.
+	// +optional
+	Tags []string `json:"tags,omitempty"`
 }
 
 // +kubebuilder:object:root=true

api/v1alpha2/linodemachinetemplate_types.go

@@ -25,6 +25,19 @@ type LinodeMachineTemplateSpec struct {
 	Template LinodeMachineTemplateResource `json:"template"`
 }
 
+// LinodeMachineTemplateStatus defines the observed state of LinodeMachineTemplate
+// It is used to store the status of the LinodeMachineTemplate, such as tags.
+type LinodeMachineTemplateStatus struct {
+
+	// tags that are currently applied to the LinodeMachineTemplate.
+	// +optional
+	Tags []string `json:"tags,omitempty"`
+
+	// Conditions represent the latest available observations of a LinodeMachineTemplate's current state.
+	// +optional
+	Conditions []metav1.Condition `json:"conditions,omitempty"`
+}
+
 // LinodeMachineTemplateResource describes the data needed to create a LinodeMachine from a template.
 type LinodeMachineTemplateResource struct {
 	Spec LinodeMachineSpec `json:"spec"`
@@ -33,6 +46,7 @@ type LinodeMachineTemplateResource struct {
 // +kubebuilder:object:root=true
 // +kubebuilder:storageversion
 // +kubebuilder:resource:path=linodemachinetemplates,scope=Namespaced,categories=cluster-api,shortName=lmt
+// +kubebuilder:subresource:status
 // +kubebuilder:metadata:labels="clusterctl.cluster.x-k8s.io/move-hierarchy=true"
 
 // LinodeMachineTemplate is the Schema for the linodemachinetemplates API
@@ -41,6 +55,29 @@ type LinodeMachineTemplate struct {
 	metav1.ObjectMeta `json:"metadata,omitempty"`
 
 	Spec LinodeMachineTemplateSpec `json:"spec,omitempty"`
+
+	Status LinodeMachineTemplateStatus `json:"status,omitempty"`
+}
+
+func (lmt *LinodeMachineTemplate) GetConditions() []metav1.Condition {
+	for i := range lmt.Status.Conditions {
+		if lmt.Status.Conditions[i].Reason == "" {
+			lmt.Status.Conditions[i].Reason = DefaultConditionReason
+		}
+	}
+	return lmt.Status.Conditions
+}
+
+func (lmt *LinodeMachineTemplate) SetConditions(conditions []metav1.Condition) {
+	lmt.Status.Conditions = conditions
+}
+
+func (lmt *LinodeMachineTemplate) GetV1Beta2Conditions() []metav1.Condition {
+	return lmt.GetConditions()
+}
+
+func (lmt *LinodeMachineTemplate) SetV1Beta2Conditions(conditions []metav1.Condition) {
+	lmt.SetConditions(conditions)
 }
 
 // +kubebuilder:object:root=true

api/v1alpha2/zz_generated.deepcopy.go

@@ -0,0 +1,77 @@
+/*
+Copyright 2025 Akamai Technologies, Inc.
+
+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 scope
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"sigs.k8s.io/cluster-api/util/patch"
+
+	infrav1alpha2 "github.com/linode/cluster-api-provider-linode/api/v1alpha2"
+	"github.com/linode/cluster-api-provider-linode/clients"
+)
+
+// MachineTemplateScope defines the basic context for an actuator to operate upon.
+type MachineTemplateScope struct {
+	PatchHelper           *patch.Helper
+	LinodeMachineTemplate *infrav1alpha2.LinodeMachineTemplate
+}
+
+// MachineTemplateScopeParams defines the input parameters used to create a new MachineTemplateScope.
+type MachineTemplateScopeParams struct {
+	Client                clients.K8sClient
+	LinodeMachineTemplate *infrav1alpha2.LinodeMachineTemplate
+}
+
+// validateMachineTemplateScope validates the parameters for creating a MachineTemplateScope.
+func validateMachineTemplateScope(params MachineTemplateScopeParams) error {
+	if params.LinodeMachineTemplate == nil {
+		return errors.New("LinodeMachineTemplate is required when creating a MachineTemplateScope")
+	}
+
+	return nil
+}
+
+// PatchObject persists the machine template configuration and status.
+func (s *MachineTemplateScope) PatchObject(ctx context.Context) error {
+	return s.PatchHelper.Patch(ctx, s.LinodeMachineTemplate)
+}
+
+// Close closes the current scope persisting the machine template configuration and status.
+func (s *MachineTemplateScope) Close(ctx context.Context) error {
+	return s.PatchObject(ctx)
+}
+
+// NewMachineTemplateScope creates a new Scope from the supplied parameters.
+// This is meant to be called for each reconcile iteration.
+func NewMachineTemplateScope(ctx context.Context, params MachineTemplateScopeParams) (*MachineTemplateScope, error) {
+	if err := validateMachineTemplateScope(params); err != nil {
+		return nil, err
+	}
+
+	helper, err := patch.NewHelper(params.LinodeMachineTemplate, params.Client)
+	if err != nil {
+		return nil, fmt.Errorf("failed to init patch helper: %w", err)
+	}
+
+	return &MachineTemplateScope{
+		LinodeMachineTemplate: params.LinodeMachineTemplate,
+		PatchHelper:           helper,
+	}, nil
+}

cloud/scope/machine_template.go

@@ -0,0 +1,130 @@
+/*
+Copyright 2025 Akamai Technologies, Inc.
+
+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 scope
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+
+	infrav1alpha2 "github.com/linode/cluster-api-provider-linode/api/v1alpha2"
+	"github.com/linode/cluster-api-provider-linode/mock"
+)
+
+func TestValidateMachineTemplateScope(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name                  string
+		LinodeMachineTemplate *infrav1alpha2.LinodeMachineTemplate
+		expErr                string
+	}{
+		{
+			name: "Success - valid LinodeMachineTemplate",
+			LinodeMachineTemplate: &infrav1alpha2.LinodeMachineTemplate{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "test-lmt",
+				},
+			},
+			expErr: "",
+		},
+		{
+			name:                  "Failure - nil LinodeMachineTemplate",
+			LinodeMachineTemplate: nil,
+			expErr:                "LinodeMachineTemplate is required when creating a MachineTemplateScope",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			err := validateMachineTemplateScope(MachineTemplateScopeParams{
+				LinodeMachineTemplate: tt.LinodeMachineTemplate,
+			})
+
+			if tt.expErr != "" {
+				assert.ErrorContains(t, err, tt.expErr)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestNewMachineTemplateScope(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name                  string
+		LinodeMachineTemplate *infrav1alpha2.LinodeMachineTemplate
+		expErr                string
+		expects               func(mock *mock.MockK8sClient)
+	}{
+		{
+			name: "Success - able to create a new MachineTemplateScope",
+			LinodeMachineTemplate: &infrav1alpha2.LinodeMachineTemplate{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "test-lmt",
+				},
+			},
+			expects: func(mock *mock.MockK8sClient) {
+				scheme := runtime.NewScheme()
+				infrav1alpha2.AddToScheme(scheme)
+				mock.EXPECT().Scheme().Return(scheme)
+			},
+		},
+		{
+			name:                  "Failure - nil LinodeMachineTemplate",
+			LinodeMachineTemplate: nil,
+			expErr:                "LinodeMachineTemplate is required",
+		},
+	}
+	for _, tt := range tests {
+		testcase := tt
+		t.Run(testcase.name, func(t *testing.T) {
+			t.Parallel()
+
+			ctrl := gomock.NewController(t)
+			defer ctrl.Finish()
+
+			mockK8sClient := mock.NewMockK8sClient(ctrl)
+
+			if tt.expects != nil {
+				tt.expects(mockK8sClient)
+			}
+
+			lmtScope, err := NewMachineTemplateScope(
+				t.Context(),
+				MachineTemplateScopeParams{
+					Client:                mockK8sClient,
+					LinodeMachineTemplate: testcase.LinodeMachineTemplate,
+				},
+			)
+
+			if tt.expErr != "" {
+				require.ErrorContains(t, err, tt.expErr)
+			} else {
+				require.NoError(t, err)
+				require.NotNil(t, lmtScope)
+				require.Equal(t, lmtScope.LinodeMachineTemplate, testcase.LinodeMachineTemplate)
+			}
+		})
+	}
+}

cloud/scope/machine_template_test.go

@@ -88,6 +88,7 @@ type flagVars struct {
 	linodeVPCConcurrency                 int
 	linodePlacementGroupConcurrency      int
 	linodeFirewallConcurrency            int
+	linodeMachineTemplateConcurrency     int
 }
 
 func init() {
@@ -152,7 +153,7 @@ func parseFlags() (flags flagVars, opts zap.Options) {
 	flag.IntVar(&flags.linodeVPCConcurrency, "linodevpc-concurrency", concurrencyDefault, "Number of LinodeVPCs to process simultaneously")
 	flag.IntVar(&flags.linodePlacementGroupConcurrency, "linodeplacementgroup-concurrency", concurrencyDefault, "Number of Linode Placement Groups to process simultaneously")
 	flag.IntVar(&flags.linodeFirewallConcurrency, "linodefirewall-concurrency", concurrencyDefault, "Number of Linode Firewall to process simultaneously")
-
+	flag.IntVar(&flags.linodeMachineTemplateConcurrency, "linodemachinetemplate-concurrency", concurrencyDefault, "Number of LinodeMachineTemplates to process simultaneously")
 	opts = zap.Options{Development: true}
 	opts.BindFlags(flag.CommandLine)
 	flag.Parse()
@@ -347,6 +348,15 @@ func setupControllers(mgr manager.Manager, flags flagVars, linodeClientConfig, d
 		setupLog.Error(err, "unable to create controller", "controller", "LinodeFirewall")
 		os.Exit(1)
 	}
+
+	// LinodeMachineTemplate Controller
+	if err := (&controller.LinodeMachineTemplateReconciler{
+		Client: mgr.GetClient(),
+		Logger: ctrl.Log.WithName("LinodeMachineTemplateReconciler"),
+	}).SetupWithManager(mgr, crcontroller.Options{MaxConcurrentReconciles: flags.linodeMachineTemplateConcurrency}); err != nil {
+		setupLog.Error(err, "unable to create controller", "controller", "LinodeMachineTemplate")
+		os.Exit(1)
+	}
 }
 
 // setupWebhooks initializes webhooks for the specified resources in the manager.