Allow to select latests versions for previous minors for selected cha…

…nnel in gke
GunaKKIBM · May 9, 2023 · 735ce85 · 735ce85
1 parent 4b2a5ce
commit 735ce85
Show file tree

Hide file tree

Showing 3 changed files with 79 additions and 13 deletions.
diff --git a/kubetest/extract_k8s.go b/kubetest/extract_k8s.go
@@ -71,16 +71,14 @@ func (l *extractStrategies) String() string {
 	return strings.Join(s, ",")
 }
 
-//^gke-?(default|channel-(rapid|regular|stable)|latest(-\d+.\d+(.\d+(-gke)?)?)?)?$
-
 // Converts --extract=release/stable, etc into an extractStrategy{}
 func (l *extractStrategies) Set(value string) error {
 	var strategies = map[string]extractMode{
 		`^(bazel)$`: localBazel,
 		`^(local)`:  local,
-		`^gke-?(default|channel-(rapid|regular|stable)(?:-(latest))?|latest(-\d+.\d+(.\d+(-gke)?)?)?)?$`: gke,
-		`^gci/([\w-]+(?:\?{1}(?::?[\w-]+=[\w-]+)+)?)$`:                                                   gci,
-		`^gci/([\w-]+(?:\?{1}(?::?[\w-]+=[\w-]+)+)?)/(.+)$`:                                              gciCi,
+		`^gke-?(default|channel-(rapid|regular|stable)(?:-((?:[0-9]-)?latest))?|latest(-\d+.\d+(.\d+(-gke)?)?)?)?$`: gke,
+		`^gci/([\w-]+(?:\?{1}(?::?[\w-]+=[\w-]+)+)?)$`:                                                              gci,
+		`^gci/([\w-]+(?:\?{1}(?::?[\w-]+=[\w-]+)+)?)/(.+)$`:                                                         gciCi,
 		`^ci/(.+)$`:                   ci,
 		`^ci/(.+)-fast$`:              ciFast,
 		`^release/(latest.*)$`:        rc,

diff --git a/kubetest/util.go b/kubetest/util.go
@@ -29,6 +29,7 @@ import (
 	"strconv"
 	"strings"
 	"time"
+	"unicode"
 )
 
 var httpTransport *http.Transport
@@ -206,20 +207,34 @@ func (g gkeVersion) String() string {
 	return fmt.Sprintf("%d.%d.%d-gke.%d", g.major, g.minor, g.patch, g.gkePatch)
 }
 
-func getGKELatestChannelVersion(raw []string) (string, error) {
-	if len(raw) == 0 {
-		return "", fmt.Errorf("channel doest not have valid versions")
-	}
+func convertToSortedGKEVersions(raw []string) ([]gkeVersion, error) {
 	v := make([]gkeVersion, 0, len(raw))
 	for _, s := range raw {
 		version, err := parseGkeVersion(s)
 		if err != nil {
-			return "", err
+			return nil, err
 		}
 		v = append(v, *version)
 	}
 	sort.Slice(v, func(i, j int) bool { return v[i].greater(v[j]) })
-	return v[0].String(), nil
+	return v, nil
+}
+
+func getGKELatestForMinor(raw []string, backstep int) (string, error) {
+	versions, err := convertToSortedGKEVersions(raw)
+	if err != nil {
+		return "", err
+	}
+	if len(versions) == 0 {
+		return "", fmt.Errorf("channel does not have valid versions")
+	}
+	targetMinor := versions[0].minor - backstep
+	for _, v := range versions {
+		if v.minor == targetMinor {
+			return v.String(), nil
+		}
+	}
+	return "", fmt.Errorf("minor %d is not available in selected channel", targetMinor)
 }
 
 // (only works on gke)
@@ -286,8 +301,12 @@ func getChannelGKEVersion(project, zone, region, gkeChannel, extractionMethod st
 
 	for _, channel := range c.Channels {
 		if strings.EqualFold(channel.Channel, gkeChannel) {
-			if strings.EqualFold(extractionMethod, "latest") {
-				latestVersion, err := getGKELatestChannelVersion(channel.ValidVersions)
+			if strings.Contains(strings.ToLower(extractionMethod), "latest") {
+				backstep := 0
+				if unicode.IsDigit(rune(extractionMethod[0])) {
+					backstep = int(extractionMethod[0]) - '0'
+				}
+				latestVersion, err := getGKELatestForMinor(channel.ValidVersions, backstep)
 				if err != nil {
 					return "", err
 				}

diff --git a/kubetest/util_test.go b/kubetest/util_test.go
@@ -101,3 +101,52 @@ func TestGetLatestClusterUpTime(t *testing.T) {
 		}
 	}
 }
+
+func TestGetGKELatestForMinor(t *testing.T) {
+	cases := []struct {
+		name            string
+		versions        []string
+		backstep        int
+		expectedVersion string
+		expectErr       bool
+	}{
+		{
+			name:            "Latest minor",
+			versions:        []string{"1.25.7-gke.1000", "1.25.8-gke.100", "1.24.3-gke.500", "1.23.3-gke.1000"},
+			backstep:        0,
+			expectedVersion: "1.25.8-gke.100",
+		},
+		{
+			name:            "Penultimate minor",
+			versions:        []string{"1.25.7-gke.1000", "1.24.4-gke.100", "1.24.3-gke.500", "1.23.3-gke.1000"},
+			backstep:        1,
+			expectedVersion: "1.24.4-gke.100",
+		},
+		{
+			name:            "Before the penultimate minor",
+			versions:        []string{"1.25.7-gke.1000", "1.24.4-gke.100", "1.24.3-gke.500", "1.23.3-gke.1000", "1.23.4-gke.800"},
+			backstep:        2,
+			expectedVersion: "1.23.4-gke.800",
+		},
+		{
+			name:            "Too old minor",
+			versions:        []string{"1.25.7-gke.1000", "1.24.4-gke.100", "1.24.3-gke.500", "1.23.3-gke.1000", "1.23.4-gke.800"},
+			backstep:        3,
+			expectedVersion: "",
+			expectErr:       true,
+		},
+	}
+
+	for _, tc := range cases {
+		v, err := getGKELatestForMinor(tc.versions, tc.backstep)
+		if err != nil && !tc.expectErr {
+			t.Errorf("%s: got unexpected error %v", tc.name, err)
+		}
+		if err == nil && tc.expectErr {
+			t.Errorf("%s: expect error but did not get one", tc.name)
+		}
+		if v != tc.expectedVersion {
+			t.Errorf("%s: expect version %s but got %s", tc.name, tc.expectedVersion, v)
+		}
+	}
+}