feat: include preview versions as fallback (#674)

* feat: include preview versions as fallback

* feat: cleanup code

* fix: review findings

* fix: review findings

* fix: linter warning

* fix: applied review comments

Author: bahkauv70

stackit/internal/services/ske/cluster/resource.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"net/http"
 	"regexp"
+	"sort"
 	"strings"
 	"time"
 
@@ -743,6 +744,33 @@ func (r *clusterResource) Create(ctx context.Context, req resource.CreateRequest
 	tflog.Info(ctx, "SKE cluster created")
 }
 
+func sortK8sVersions(versions []ske.KubernetesVersion) {
+	sort.Slice(versions, func(i, j int) bool {
+		v1, v2 := (versions)[i].Version, (versions)[j].Version
+		if v1 == nil {
+			return false
+		}
+		if v2 == nil {
+			return true
+		}
+
+		// we have to make copies of the input strings to add prefixes,
+		// otherwise we would be changing the passed elements
+		t1, t2 := *v1, *v2
+
+		if !strings.HasPrefix(t1, "v") {
+			t1 = "v" + t1
+		}
+		if !strings.HasPrefix(t2, "v") {
+			t2 = "v" + t2
+		}
+		return semver.Compare(t1, t2) > 0
+	})
+}
+
+// loadAvailableVersions loads the available k8s and machine versions from the API.
+// The k8s versions are sorted  descending order, i.e. the latest versions (including previews)
+// are listed first
 func (r *clusterResource) loadAvailableVersions(ctx context.Context) ([]ske.KubernetesVersion, []ske.MachineImage, error) {
 	c := r.skeClient
 	res, err := c.ListProviderOptions(ctx).Execute()
@@ -793,7 +821,7 @@ func (r *clusterResource) createOrUpdateCluster(ctx context.Context, diags *diag
 	// cluster vars
 	projectId := model.ProjectId.ValueString()
 	name := model.Name.ValueString()
-	kubernetes, hasDeprecatedVersion, err := toKubernetesPayload(model, availableKubernetesVersions, currentKubernetesVersion)
+	kubernetes, hasDeprecatedVersion, err := toKubernetesPayload(model, availableKubernetesVersions, currentKubernetesVersion, diags)
 	if err != nil {
 		core.LogAndAddError(ctx, diags, "Error creating/updating cluster", fmt.Sprintf("Creating cluster config API payload: %v", err))
 		return
@@ -1813,7 +1841,7 @@ func mapExtensions(ctx context.Context, cl *ske.Cluster, m *Model) error {
 	return nil
 }
 
-func toKubernetesPayload(m *Model, availableVersions []ske.KubernetesVersion, currentKubernetesVersion *string) (kubernetesPayload *ske.Kubernetes, hasDeprecatedVersion bool, err error) {
+func toKubernetesPayload(m *Model, availableVersions []ske.KubernetesVersion, currentKubernetesVersion *string, diags *diag.Diagnostics) (kubernetesPayload *ske.Kubernetes, hasDeprecatedVersion bool, err error) {
 	providedVersionMin := m.KubernetesVersionMin.ValueStringPointer()
 
 	if !m.KubernetesVersion.IsNull() {
@@ -1823,7 +1851,7 @@ func toKubernetesPayload(m *Model, availableVersions []ske.KubernetesVersion, cu
 		providedVersionMin = conversion.StringValueToPointer(m.KubernetesVersion)
 	}
 
-	versionUsed, hasDeprecatedVersion, err := latestMatchingKubernetesVersion(availableVersions, providedVersionMin, currentKubernetesVersion)
+	versionUsed, hasDeprecatedVersion, err := latestMatchingKubernetesVersion(availableVersions, providedVersionMin, currentKubernetesVersion, diags)
 	if err != nil {
 		return nil, false, fmt.Errorf("getting latest matching kubernetes version: %w", err)
 	}
@@ -1835,9 +1863,7 @@ func toKubernetesPayload(m *Model, availableVersions []ske.KubernetesVersion, cu
 	return k, hasDeprecatedVersion, nil
 }
 
-func latestMatchingKubernetesVersion(availableVersions []ske.KubernetesVersion, kubernetesVersionMin, currentKubernetesVersion *string) (version *string, deprecated bool, err error) {
-	deprecated = false
-
+func latestMatchingKubernetesVersion(availableVersions []ske.KubernetesVersion, kubernetesVersionMin, currentKubernetesVersion *string, diags *diag.Diagnostics) (version *string, deprecated bool, err error) {
 	if availableVersions == nil {
 		return nil, false, fmt.Errorf("nil available kubernetes versions")
 	}
@@ -1865,58 +1891,113 @@ func latestMatchingKubernetesVersion(availableVersions []ske.KubernetesVersion,
 		}
 	}
 
-	var fullVersion bool
-	versionExp := validate.FullVersionRegex
-	versionRegex := regexp.MustCompile(versionExp)
-	if versionRegex.MatchString(*kubernetesVersionMin) {
-		fullVersion = true
-	}
+	versionRegex := regexp.MustCompile(validate.FullVersionRegex)
+	fullVersion := versionRegex.MatchString(*kubernetesVersionMin)
 
 	providedVersionPrefixed := "v" + *kubernetesVersionMin
-
 	if !semver.IsValid(providedVersionPrefixed) {
 		return nil, false, fmt.Errorf("provided version is invalid")
 	}
 
-	var versionUsed *string
-	var state *string
-	var availableVersionsArray []string
-	// Get the higher available version that matches the major, minor and patch version provided by the user
-	for _, v := range availableVersions {
-		if v.State == nil || v.Version == nil {
+	var (
+		selectedVersion        *ske.KubernetesVersion
+		availableVersionsArray []string
+	)
+	if fullVersion {
+		availableVersionsArray, selectedVersion = selectFullVersion(availableVersions, providedVersionPrefixed)
+	} else {
+		availableVersionsArray, selectedVersion = selectMatchingVersion(availableVersions, providedVersionPrefixed)
+	}
+
+	deprecated = isDeprecated(selectedVersion)
+
+	if isPreview(selectedVersion) {
+		diags.AddWarning("preview version selected", fmt.Sprintf("only the preview version %q matched the selection criteria", *selectedVersion.Version))
+	}
+
+	// Throwing error if we could not match the version with the available versions
+	if selectedVersion == nil {
+		return nil, false, fmt.Errorf("provided version is not one of the available kubernetes versions, available versions are: %s", strings.Join(availableVersionsArray, ","))
+	}
+
+	return selectedVersion.Version, deprecated, nil
+}
+
+func selectFullVersion(availableVersions []ske.KubernetesVersion, kubernetesVersionMin string) (availableVersionsArray []string, selectedVersion *ske.KubernetesVersion) {
+	for _, versionCandidate := range availableVersions {
+		if versionCandidate.State == nil || versionCandidate.Version == nil {
 			continue
 		}
-		availableVersionsArray = append(availableVersionsArray, *v.Version)
-		vPreffixed := "v" + *v.Version
+		availableVersionsArray = append(availableVersionsArray, *versionCandidate.Version)
+		vPrefixed := "v" + *versionCandidate.Version
 
-		if fullVersion {
-			// [MAJOR].[MINOR].[PATCH] version provided, match available version
-			if semver.Compare(vPreffixed, providedVersionPrefixed) == 0 {
-				versionUsed = v.Version
-				state = v.State
-				break
-			}
-		} else {
-			// [MAJOR].[MINOR] version provided, get the latest non-preview patch version
-			if semver.MajorMinor(vPreffixed) == semver.MajorMinor(providedVersionPrefixed) &&
-				(semver.Compare(vPreffixed, providedVersionPrefixed) == 1 || semver.Compare(vPreffixed, providedVersionPrefixed) == 0) &&
-				(v.State != nil && *v.State != VersionStatePreview) {
-				versionUsed = v.Version
-				state = v.State
+		// [MAJOR].[MINOR].[PATCH] version provided, match available version
+		if semver.Compare(vPrefixed, kubernetesVersionMin) == 0 {
+			selectedVersion = &versionCandidate
+			break
+		}
+	}
+	return availableVersionsArray, selectedVersion
+}
+
+func selectMatchingVersion(availableVersions []ske.KubernetesVersion, kubernetesVersionMin string) (availableVersionsArray []string, selectedVersion *ske.KubernetesVersion) {
+	sortK8sVersions(availableVersions)
+	for _, candidateVersion := range availableVersions {
+		if candidateVersion.State == nil || candidateVersion.Version == nil {
+			continue
+		}
+		availableVersionsArray = append(availableVersionsArray, *candidateVersion.Version)
+		vPreffixed := "v" + *candidateVersion.Version
+
+		// [MAJOR].[MINOR] version provided, get the latest non-preview patch version
+		if semver.MajorMinor(vPreffixed) == semver.MajorMinor(kubernetesVersionMin) &&
+			(semver.Compare(vPreffixed, kubernetesVersionMin) >= 0) &&
+			(candidateVersion.State != nil) {
+			// take the current version as a candidate, if we have no other version inspected before
+			// OR the previously found version was a preview version
+			if selectedVersion == nil || (isSupported(&candidateVersion) && isPreview(selectedVersion)) {
+				selectedVersion = &candidateVersion
 			}
+			// all other cases are ignored
 		}
 	}
+	return availableVersionsArray, selectedVersion
+}
 
-	if versionUsed != nil {
-		deprecated = strings.EqualFold(*state, VersionStateDeprecated)
+func isDeprecated(v *ske.KubernetesVersion) bool {
+	if v == nil {
+		return false
 	}
 
-	// Throwing error if we could not match the version with the available versions
-	if versionUsed == nil {
-		return nil, false, fmt.Errorf("provided version is not one of the available kubernetes versions, available versions are: %s", strings.Join(availableVersionsArray, ","))
+	if v.State == nil {
+		return false
 	}
 
-	return versionUsed, deprecated, nil
+	return *v.State == VersionStateDeprecated
+}
+
+func isPreview(v *ske.KubernetesVersion) bool {
+	if v == nil {
+		return false
+	}
+
+	if v.State == nil {
+		return false
+	}
+
+	return *v.State == VersionStatePreview
+}
+
+func isSupported(v *ske.KubernetesVersion) bool {
+	if v == nil {
+		return false
+	}
+
+	if v.State == nil {
+		return false
+	}
+
+	return *v.State == VersionStateSupported
 }
 
 func getLatestSupportedKubernetesVersion(versions []ske.KubernetesVersion) (*string, error) {