add version

Author: yeoldegrove

src/python_gardenlinux_lib/__init__.py

@@ -1,3 +1,4 @@
 from .git import Git
+from .version import Version
 
-__all__ = ['Git']
+__all__ = ["Git", "Version"]

src/python_gardenlinux_lib/version.py

@@ -0,0 +1,169 @@
+import re
+import subprocess
+from datetime import datetime, timezone
+import requests
+from pathlib import Path
+
+from .logger import LoggerSetup
+from .features.parse_features import get_features
+
+
+class Version:
+    """Handles version-related operations for Garden Linux."""
+
+    def __init__(self, git_root: Path, logger=None):
+        """Initialize Version handler.
+
+        Args:
+            git_root: Path to the Git repository root
+            logger: Optional logger instance
+        """
+        self.git_root = git_root
+        self.log = logger or LoggerSetup.get_logger("gardenlinux.version")
+        self.start_date = "Mar 31 00:00:00 UTC 2020"
+
+    def get_minor_from_repo(self, major):
+        """Check repo.gardenlinux.io for highest available suite minor for given major.
+
+        Args:
+            major: major version
+        Returns:
+            minor version
+        """
+        minor = 0
+        limit = 100  # Hard limit the search
+        repo_url = f"https://repo.gardenlinux.io/gardenlinux/dists/{major}.{{}}/Release"
+
+        while minor <= limit:
+            try:
+                check_url = repo_url.format(minor)
+                response = requests.get(check_url)
+                if response.status_code != 200:
+                    # No more versions found, return last successful minor
+                    return minor - 1
+                minor += 1
+            except requests.RequestException as e:
+                self.log.debug(f"Error checking repo URL {check_url}: {e}")
+                return minor - 1
+
+        # If we hit the limit, return the last minor
+        return minor - 1
+
+    def get_version(self):
+        """Get version using same logic as garden-version bash script.
+
+        Args:
+            version: version string
+        Returns:
+            version string
+        """
+
+        try:
+            # Check VERSION file
+            version_file = self.git_root / "VERSION"
+            if version_file.exists():
+                version = version_file.read_text().strip()
+                # Remove comments and empty lines
+                version = re.sub(r"#.*$", "", version, flags=re.MULTILINE)
+                version = "\n".join(
+                    line for line in version.splitlines() if line.strip()
+                )
+                version = version.strip()
+            else:
+                version = "today"
+
+            if not version:
+                version = "today"
+
+            # Handle numeric versions (e.g., "27.1")
+            if re.match(r"^[0-9\.]*$", version):
+                major = version.split(".")[0]
+                if int(major) < 10000000:  # Sanity check for major version
+                    if "." in version:
+                        return version  # Return full version if minor is specified
+                    else:
+                        # Get latest minor version from repo
+                        minor = self.get_minor_from_repo(major)
+                        return f"{major}.{minor}"
+
+            # Handle 'today' or 'experimental'
+            if version in ["today", "experimental"]:
+                # Calculate days since start date
+                start_timestamp = datetime.strptime(
+                    self.start_date, "%b %d %H:%M:%S %Z %Y"
+                ).timestamp()
+                today_timestamp = datetime.now(timezone.utc).timestamp()
+                major = int((today_timestamp - start_timestamp) / (24 * 60 * 60))
+                return version
+
+            # Handle date input
+            try:
+                # Try to parse as date
+                input_date = datetime.strptime(version, "%Y%m%d")
+                start_date = datetime.strptime(self.start_date, "%b %d %H:%M:%S %Z %Y")
+                days_diff = (input_date - start_date).days
+                return f"{days_diff}.0"
+            except ValueError:
+                pass
+
+            return version
+
+        except Exception as e:
+            self.log.error(f"Error determining version: {e}")
+            return "local"
+
+    def get_short_commit(self):
+        """Get short commit using same logic as the get_commit bash script.
+
+        Returns:
+            short commit string
+        """
+        try:
+            # Check if COMMIT file exists in git root
+            commit_file = self.git_root / "COMMIT"
+            if commit_file.exists():
+                return commit_file.read_text().strip()
+
+            # Check if git repo is clean
+            status_output = (
+                subprocess.check_output(
+                    ["git", "status", "--porcelain"], stderr=subprocess.DEVNULL
+                )
+                .decode()
+                .strip()
+            )
+
+            if status_output:
+                self.log.info(f"git status:\n {status_output}")
+                # Dirty repo or not a git repo
+                return "local"
+            else:
+                # Clean repo - use git commit hash
+                return (
+                    subprocess.check_output(
+                        ["git", "rev-parse", "--short", "HEAD"],
+                        stderr=subprocess.DEVNULL,
+                    )
+                    .decode()
+                    .strip()
+                )
+
+        except subprocess.CalledProcessError:
+            return "local"
+
+    def get_cname(self, platform, features, arch):
+        """Get canonical name (cname) for Garden Linux image.
+
+        Args:
+            platform: Platform identifier (e.g., 'kvm', 'aws')
+            features: List of features
+            arch: Architecture ('amd64' or 'arm64')
+
+        Returns:
+            Generated cname string
+        """
+        # Get version and commit
+        version = self.get_version()
+        commit = self.get_short_commit()
+
+        return f"{platform}-{features}-{arch}-{version}-{commit}"