Initial groundwork for VLAN controller

api/v1alpha1/conversion.go

@@ -86,3 +86,8 @@ func Convert_v1alpha2_LinodeObjectStorageBucket_To_v1alpha1_LinodeObjectStorageB
  }
  return autoConvert_v1alpha2_LinodeObjectStorageBucket_To_v1alpha1_LinodeObjectStorageBucket(in, out, scope)
 }
+
+func Convert_v1alpha2_LinodeClusterSpec_To_v1alpha1_LinodeClusterSpec(in *infrastructurev1alpha2.LinodeClusterSpec, out *LinodeClusterSpec, scope conversion.Scope) error {
+ // VLAN is not supported in v1alpha1
+ return autoConvert_v1alpha2_LinodeClusterSpec_To_v1alpha1_LinodeClusterSpec(in, out, scope)
+}

api/v1alpha2/linodecluster_types.go

@@ -43,6 +43,11 @@ type LinodeClusterSpec struct {
  // +optional
  Network NetworkSpec `json:"network"`
 
+ // UseVlan provisions a cluster that uses VLANs instead of VPCs. IPAM is managed internally.
+ // +kubebuilder:validation:XValidation:rule="self == oldSelf",message="Value is immutable"
+ // +optional
+ UseVlan bool `json:"useVlan"`
+
  // +kubebuilder:validation:XValidation:rule="self == oldSelf",message="Value is immutable"
  // +optional
  VPCRef *corev1.ObjectReference `json:"vpcRef,omitempty"`

api/v1alpha2/linodecluster_webhook.go

@@ -106,6 +106,13 @@
  }
  }
 
+ if r.Spec.UseVlan && r.Spec.VPCRef != nil {
+ errs = append(errs, &field.Error{
+ Field: "Cannot use VLANs and VPCs together. Unset `useVlan` or remove `vpcRef`",
+ Type: field.ErrorTypeInvalid,
+ })
+ }
+
  if len(errs) == 0 {
  return nil
  }

config/crd/bases/infrastructure.cluster.x-k8s.io_linodeclusters.yaml

@@ -407,6 +407,13 @@ spec:
  region:
  description: The Linode Region the LinodeCluster lives in.
  type: string
+ useVlan:
+ description: UseVlan provisions a cluster that uses VLANs instead
+ of VPCs. IPAM is managed internally.
+ type: boolean
+ x-kubernetes-validations:
+ - message: Value is immutable
+ rule: self == oldSelf
  vpcRef:
  description: |-
  ObjectReference contains enough information to let you inspect or modify the referred object.

config/crd/bases/infrastructure.cluster.x-k8s.io_linodeclustertemplates.yaml

@@ -335,6 +335,13 @@ spec:
  region:
  description: The Linode Region the LinodeCluster lives in.
  type: string
+ useVlan:
+ description: UseVlan provisions a cluster that uses VLANs
+ instead of VPCs. IPAM is managed internally.
+ type: boolean
+ x-kubernetes-validations:
+ - message: Value is immutable
+ rule: self == oldSelf
  vpcRef:
  description: |-
  ObjectReference contains enough information to let you inspect or modify the referred object.

controller/linodemachine_controller_helpers.go

@@ -24,15 +24,19 @@
  "errors"
  "fmt"
  "net/http"
+ "net/netip"
  "slices"
  "sort"
 
  "github.com/go-logr/logr"
  "github.com/google/uuid"
  "github.com/linode/linodego"
+ "golang.org/x/exp/maps"
+ corev1 "k8s.io/api/core/v1"
  apierrors "k8s.io/apimachinery/pkg/api/errors"
  "k8s.io/apimachinery/pkg/api/resource"
  metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ "k8s.io/client-go/util/retry"
  "k8s.io/utils/ptr"
  clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
  cerrs "sigs.k8s.io/cluster-api/errors"
@@ -80,24 +84,7 @@
  return ctrl.Result{}, err
 }
 
-func newCreateConfig(ctx context.Context, machineScope *scope.MachineScope, logger logr.Logger) (*linodego.InstanceCreateOptions, error) {
- var err error
-
- createConfig := linodeMachineSpecToInstanceCreateConfig(machineScope.LinodeMachine.Spec)
- if createConfig == nil {
- err = errors.New("failed to convert machine spec to create instance config")
-
- logger.Error(err, "Panic! Struct of LinodeMachineSpec is different than InstanceCreateOptions")
-
- return nil, err
- }
-
- createConfig.Booted = util.Pointer(false)
-
- if err := setUserData(ctx, machineScope, createConfig, logger); err != nil {
- return nil, err
- }
-
+func fillCreateConfig(createConfig *linodego.InstanceCreateOptions, machineScope *scope.MachineScope) {
  if machineScope.LinodeMachine.Spec.PrivateIP != nil {
  createConfig.PrivateIP = *machineScope.LinodeMachine.Spec.PrivateIP
  } else {
@@ -119,8 +106,28 @@
  if createConfig.RootPass == "" {
  createConfig.RootPass = uuid.NewString()
  }
+}
+
+func newCreateConfig(ctx context.Context, machineScope *scope.MachineScope, logger logr.Logger) (*linodego.InstanceCreateOptions, error) {
+ var err error
+
+ createConfig := linodeMachineSpecToInstanceCreateConfig(machineScope.LinodeMachine.Spec)
+ if createConfig == nil {
+ err = errors.New("failed to convert machine spec to create instance config")
+
+ logger.Error(err, "Panic! Struct of LinodeMachineSpec is different than InstanceCreateOptions")
+
+ return nil, err
+ }
+
+ createConfig.Booted = util.Pointer(false)
+ if err := setUserData(ctx, machineScope, createConfig, logger); err != nil {
+ return nil, err
+ }
+
+ fillCreateConfig(createConfig, machineScope)
 
- // if vpc, attach additional interface as eth0 to linode
+ // if vpc is enabled, attach additional interface as eth0 to linode
  if machineScope.LinodeCluster.Spec.VPCRef != nil {
  iface, err := getVPCInterfaceConfig(ctx, machineScope, createConfig.Interfaces, logger)
  if err != nil {
@@ -134,6 +141,19 @@
  }
  }
 
+ // if vlan is enabled, attach additional interface as eth0 to linode
+ if machineScope.LinodeCluster.Spec.UseVlan {
+ iface, err := getVlanInterfaceConfig(ctx, machineScope, logger)
+ if err != nil {
+ logger.Error(err, "Failed to get VLAN interface config")
+ return nil, err
+ }
+ if iface != nil {
+ // add VLAN interface as first interface
+ createConfig.Interfaces = slices.Insert(createConfig.Interfaces, 0, *iface)
+ }
+ }
+
  if machineScope.LinodeMachine.Spec.PlacementGroupRef != nil {
  pgID, err := getPlacementGroupID(ctx, machineScope, logger)
  if err != nil {
@@ -191,14 +211,21 @@
  Type: clusterv1.MachineExternalIP,
  })
 
- // Iterate over interfaces in config and find VPC specific ips
+ // Iterate over interfaces in config and find VPC or VLAN specific ips
  for _, iface := range configs[0].Interfaces {
  if iface.VPCID != nil && iface.IPv4.VPC != "" {
  ips = append(ips, clusterv1.MachineAddress{
  Address: iface.IPv4.VPC,
  Type: clusterv1.MachineInternalIP,
  })
  }
+
+ if iface.Purpose == linodego.InterfacePurposeVLAN {
+ ips = append(ips, clusterv1.MachineAddress{
+ Address: iface.IPAMAddress,
+ Type: clusterv1.MachineInternalIP,
+ })
+ }
  }
 
  // if a node has private ip, store it as well
@@ -345,6 +372,74 @@
  return *linodeFirewall.Spec.FirewallID, nil
 }
 
+func getNextIP(ips []string, prefixStr string) string {
+ prefix := netip.MustParsePrefix(prefixStr)
+ currentIp := prefix.Addr().Next()
+
+ ipString := currentIp.String()
+ for {
+ if slices.Contains(ips, ipString) {
+ break
+ }
+ currentIp = currentIp.Next()
+ ipString = currentIp.String()
+ }
+ return ipString
+}
+
+func reserveNextIP(ctx context.Context, machineScope *scope.MachineScope, logger logr.Logger) (string, error) {
+ namespace := machineScope.Cluster.Namespace
+ clusterName := machineScope.Cluster.Name
+
+ var ipsMap corev1.ConfigMap
+ err := machineScope.Client.Get(ctx, client.ObjectKey{Namespace: namespace, Name: fmt.Sprintf("%s-ips", clusterName)}, &ipsMap)
+ if err != nil && !apierrors.IsNotFound(err) {
+ return "", fmt.Errorf("retreiving ips configmap %s/%s: %w", namespace, fmt.Sprintf("%s-ips", clusterName), err)
+ }
+
+ if ip, ok := ipsMap.Data[machineScope.LinodeMachine.Name]; ok {
+ return ip, nil
+ }
+
+ var nextIP string
+ err = retry.RetryOnConflict(retry.DefaultRetry, func() error {
+ if err = machineScope.Client.Get(ctx, client.ObjectKeyFromObject(&ipsMap), &ipsMap); err != nil {
+ return fmt.Errorf("retreiving ips configmap %s/%s: %w", namespace, fmt.Sprintf("%s-ips", clusterName), err)
+ }
+
+ nextIP = getNextIP(maps.Values(ipsMap.Data), "10.0.0.0/11")
+ ipsMap.Data[machineScope.LinodeMachine.Name] = nextIP
+ if err := machineScope.Client.Update(ctx, &ipsMap); err != nil {
+ return fmt.Errorf("updating ips configMap: %w", err)
+ }
+ return nil
+ })
+ if err != nil {
+ return "", err
+ }
+
+ logger.Info("onbained IP for machine", "name", machineScope.LinodeMachine.Name, "ip", nextIP)
+ // if an IP is available
+ return nextIP, nil
+}
+
+func getVlanInterfaceConfig(ctx context.Context, machineScope *scope.MachineScope, logger logr.Logger) (*linodego.InstanceConfigInterfaceCreateOptions, error) {
+ logger = logger.WithValues("vlanName", machineScope.Cluster.Name)
+
+ // Try to obtain a IP for the machine using its name
+
+ ip, err := reserveNextIP(ctx, machineScope, logger)
+ if err != nil {
+ return nil, err
+ }
+
+ return &linodego.InstanceConfigInterfaceCreateOptions{
+ Purpose: linodego.InterfacePurposeVLAN,
+ Label: machineScope.Cluster.Name,
+ IPAMAddress: ip,
+ }, nil
+}
+
 func getVPCInterfaceConfig(ctx context.Context, machineScope *scope.MachineScope, interfaces []linodego.InstanceConfigInterfaceCreateOptions, logger logr.Logger) (*linodego.InstanceConfigInterfaceCreateOptions, error) {
  name := machineScope.LinodeCluster.Spec.VPCRef.Name
  namespace := machineScope.LinodeCluster.Spec.VPCRef.Namespace