Remove tarball requirement for image build, parse image digests

Author: justin-lesko

tasks/k8s_versions.py

@@ -10,7 +10,6 @@
 import os
 import re
 import sys
-from functools import total_ordering
 
 from invoke.exceptions import Exit
 from invoke.tasks import task
@@ -27,64 +26,25 @@
 except ImportError:
     yaml = None
 
+try:
+    import semver
+except ImportError:
+    semver = None
 
 DOCKER_HUB_API_URL = "https://hub.docker.com/v2/repositories/kindest/node/tags"
 VERSIONS_FILE = "k8s_versions.json"
 E2E_YAML_PATH = ".gitlab/e2e/e2e.yml"
 
 
-@total_ordering
-class Version:
-    """Kubernetes version with proper semantic version comparison.
-
-    Handles both final releases and RC (release candidate) versions:
-    - v1.35.0-rc.1 < v1.35.0-rc.2 < v1.35.0
-    """
-
-    def __init__(self, major: int, minor: int, patch: int, rc: int | None = None):
-        self.major = major
-        self.minor = minor
-        self.patch = patch
-        self.rc = rc  # None for final releases, number for RC versions
-
-    def __eq__(self, other):
-        if not isinstance(other, Version):
-            return NotImplemented
-        return (self.major, self.minor, self.patch, self.rc) == (
-            other.major,
-            other.minor,
-            other.patch,
-            other.rc,
-        )
-
-    def __lt__(self, other):
-        if not isinstance(other, Version):
-            return NotImplemented
-
-        # Compare major, minor, patch first
-        # If they aren't equal, then return the tuple comparison
-        if (self.major, self.minor, self.patch) != (other.major, other.minor, other.patch):
-            return (self.major, self.minor, self.patch) < (other.major, other.minor, other.patch)
-
-        # If base versions are equal, compare RC status
-        # RC versions are less than final releases: v1.35.0-rc.1 < v1.35.0
-        if self.rc is None:
-            return False  # self is final (>= any RC or final with same base version)
-        return other.rc is None or self.rc < other.rc  # self is RC, so less than final OR compare RC numbers
-
-    def __repr__(self):
-        if self.rc is None:
-            return f"Version({self.major}.{self.minor}.{self.patch})"
-        return f"Version({self.major}.{self.minor}.{self.patch}-rc.{self.rc})"
-
-
 def _check_dependencies():
     """Check if required dependencies are installed."""
     missing = []
     if requests is None:
         missing.append('requests')
     if yaml is None:
         missing.append('pyyaml')
+    if semver is None:
+        missing.append('semver')
 
     if missing:
         raise Exit(
@@ -93,28 +53,26 @@ def _check_dependencies():
         )
 
 
-def _parse_version(version_str: str) -> Version | None:
+def _parse_version(version_str: str) -> semver.VersionInfo | None:
     """
-    Parse a Kubernetes version string into a Version object.
+    Parse a Kubernetes version string into a semver VersionInfo object.
+
+    Semver naturally handles RC versions correctly:
+    - v1.35.0-rc.1 < v1.35.0-rc.2 < v1.35.0
 
     Examples:
-        'v1.34.0' -> Version(1, 34, 0)
-        'v1.35.0-rc.1' -> Version(1, 35, 0, rc=1)
+        'v1.34.0' -> VersionInfo(1, 34, 0)
+        'v1.35.0-rc.1' -> VersionInfo(1, 35, 0, prerelease='rc.1')
 
     Returns None if the version string is invalid.
     """
-    # Match a release version
-    match = re.match(r'^v?(\d+)\.(\d+)\.(\d+)$', version_str)
-    if match:
-        major, minor, patch = map(int, match.groups())
-        return Version(major, minor, patch)
-    # Match an RC version
-    rc_match = re.match(r'^v?(\d+)\.(\d+)\.(\d+)\-rc\.(\d+)$', version_str)
-    if rc_match:
-        major, minor, patch, rc = map(int, rc_match.groups())
-        return Version(major, minor, patch, rc=rc)
+    # Remove leading 'v' if present
+    clean_version = version_str.lstrip('v')
 
-    return None
+    try:
+        return semver.VersionInfo.parse(clean_version)
+    except (ValueError, AttributeError):
+        return None
 
 
 def _get_docker_hub_tags() -> list[dict]:
@@ -158,8 +116,7 @@ def _get_latest_k8s_versions() -> dict[str, dict[str, str]]:
     version_tags = []
 
     # Final release Kubernetes version tags
-    _ = _get_docker_hub_tags()  # TODO: add this back when testing of RCs is done
-    for tag in []:
+    for tag in _get_docker_hub_tags():
         tag_name = tag.get('name', '')
         version = _parse_version(tag_name)
 
@@ -171,11 +128,10 @@ def _get_latest_k8s_versions() -> dict[str, dict[str, str]]:
     # RC Kubernetes version tags
     for tag in get_github_rc_releases():
         tag_name = tag.get('tag_name', '')
-        tarball = tag.get('tarball_url')
         version = _parse_version(tag_name)
-        if version and tag_name and tarball:
+        if version and tag_name:
             # Hardcode 'rc' to True because get_github_rc_releases() only returns rc releases
-            version_tags.append({'version': version, 'tag': tag_name, 'rc': True, 'tarball': tarball})
+            version_tags.append({'version': version, 'tag': tag_name, 'rc': True})
 
     # Sort by version (major, minor, patch)
     version_tags.sort(key=lambda x: x['version'], reverse=True)
@@ -188,19 +144,16 @@ def _get_latest_k8s_versions() -> dict[str, dict[str, str]]:
         tag = latest.get('tag')
         digest = latest.get('digest')
         rc = latest.get('rc')
-        tarball = latest.get('tarball')
 
         # Build return dictionary
-        # Structure: {tag_name: {'tag': tag_name, 'digest': digest?, 'rc': bool?, 'tarball': url?}}
-        # Final releases include 'digest', RC releases include 'rc' and 'tarball'
+        # Structure: {tag_name: {'tag': tag_name, 'digest': digest?, 'rc': bool?}}
+        # Final releases include 'digest', RC releases include 'rc'
         if tag:
             result = {tag: {'tag': tag}}
             if digest:
                 result[tag]['digest'] = digest
             if rc:
                 result[tag]['rc'] = rc
-            if tarball:
-                result[tag]['tarball'] = tarball
             return result
 
     return {}
@@ -226,11 +179,29 @@ def _save_versions(versions: dict[str, dict[str, str]], versions_file: str) -> N
 def _find_new_versions(
     current: dict[str, dict[str, str]], previous: dict[str, dict[str, str]]
 ) -> dict[str, dict[str, str]]:
-    """Find versions that are new or have different digests."""
+    """Find versions that are new or have different digests.
+
+    Notes:
+        - RC versions from GitHub won't have digests initially
+        - Only compare digests if BOTH current and previous have them
+        - If current has no digest (RC from GitHub) and version exists, don't mark as new
+    """
     new_versions = {}
 
     for version, data in current.items():
-        if version not in previous or previous[version].get('digest') != data.get('digest'):
+        # Version doesn't exist in previous - it's new
+        if version not in previous:
+            new_versions[version] = data
+            continue
+
+        # Version exists - check if digest changed
+        current_digest = data.get('digest')
+        previous_digest = previous[version].get('digest')
+
+        # Only compare digests if BOTH have them
+        # This prevents RC versions (no digest from GitHub) from being marked as new
+        # when they already exist in the saved file (with digest from build)
+        if current_digest and previous_digest and current_digest != previous_digest:
             new_versions[version] = data
 
     return new_versions
@@ -436,10 +407,7 @@ def fetch_versions(_, output_file=VERSIONS_FILE):
     latest_data = current_versions[latest_version]
 
     print(f"Latest Kubernetes version: {latest_version}")
-    if latest_data.get('tarball'):
-        print(f"  Tarball: {latest_data['tarball']}")
-    else:
-        print(f"  Digest: {latest_data['digest']}")
+    print(f"  Digest: {latest_data.get('digest', 'Digest unknown')}")
 
     # Load previous versions and compare
     previous_versions = _load_existing_versions(output_file)
@@ -448,10 +416,7 @@ def fetch_versions(_, output_file=VERSIONS_FILE):
     if new_versions:
         print("\nNew version(s) found!")
         for version, data in new_versions.items():
-            if data.get('tarball'):
-                print(f"  {version}: {data['tarball']}")
-            else:
-                print(f"  {version}: {data['digest']}")
+            print(f"  {version}: {data.get('digest', 'Digest unknown')}")
 
         # Set GitHub Actions outputs
         _set_github_output('has_new_versions', 'true')