Massive fixes, new display stage, fix edge case for version

Author: Peter-Sh

src/redis_release/bht/behaviours.py

@@ -19,6 +19,7 @@
 from datetime import datetime
 from typing import Any, Dict, List, Optional
 
+from py import log
 from py_trees.behaviour import Behaviour
 from py_trees.common import Status
 
@@ -738,22 +739,51 @@ def update(self) -> Status:
         return Status.SUCCESS
 
 
-class DetectHomebrewChannel(ReleaseAction):
+class HomewbrewWorkflowInputs(ReleaseAction):
     def __init__(
         self,
         name: str,
+        workflow: Workflow,
         package_meta: HomebrewMeta,
         release_meta: ReleaseMeta,
         log_prefix: str = "",
     ) -> None:
+        self.workflow = workflow
         self.package_meta = package_meta
         self.release_meta = release_meta
+        super().__init__(name=f"{name} - homebrew", log_prefix=log_prefix)
+
+    def update(self) -> Status:
+        if self.package_meta.release_type is not None:
+            self.workflow.inputs["release_type"] = self.package_meta.release_type.value
+        if self.release_meta.tag is not None:
+            self.workflow.inputs["release_tag"] = self.release_meta.tag
+        if self.package_meta.homebrew_channel is not None:
+            self.workflow.inputs["channel"] = self.package_meta.homebrew_channel.value
+        return Status.SUCCESS
+
+
+class DetectHombrewReleaseAndChannel(ReleaseAction):
+    def __init__(
+        self,
+        name: str,
+        package_meta: HomebrewMeta,
+        release_meta: ReleaseMeta,
+        log_prefix: str = "",
+    ) -> None:
+        self.package_meta = package_meta
+        self.release_meta = release_meta
+        self.release_version: Optional[RedisVersion] = None
         super().__init__(name=name, log_prefix=log_prefix)
 
     def initialise(self) -> None:
         if self.release_meta.tag is None:
             self.logger.error("Release tag is not set")
             return
+        if self.release_version is not None:
+            return
+
+        self.feedback_message = ""
         try:
             self.release_version = RedisVersion.parse(self.release_meta.tag)
         except ValueError as e:
@@ -762,24 +792,37 @@ def initialise(self) -> None:
 
     def update(self) -> Status:
         if self.release_meta.tag is None:
+            logger.error("Release tag is not set")
             return Status.FAILURE
 
-        msg = ""
-        if self.release_version.is_internal:
-            msg = "Hombebrew internal release detected"
-        if self.release_version.is_rc:
-            self.package_meta.homebrew_channel = HomebrewChannel.RC
-            msg = "Homebrew channel detected: rc"
-        elif self.release_version.is_ga:
-            msg = "Homebrew channel detected: stable"
-            self.package_meta.homebrew_channel = HomebrewChannel.STABLE
+        if (
+            self.package_meta.homebrew_channel is not None
+            and self.package_meta.release_type is not None
+        ):
+            pass
         else:
-            msg = "Homebrew channel not detected"
+            assert self.release_version is not None
+            if self.release_version.is_internal:
+                self.package_meta.release_type = ReleaseType.INTERNAL
+                self.package_meta.homebrew_channel = HomebrewChannel.RC
+            else:
+                if self.release_version.is_ga:
+                    self.package_meta.release_type = ReleaseType.PUBLIC
+                    self.package_meta.homebrew_channel = HomebrewChannel.STABLE
+                elif self.release_version.is_rc:
+                    self.package_meta.release_type = ReleaseType.PUBLIC
+                    self.package_meta.homebrew_channel = HomebrewChannel.RC
+                else:
+                    self.package_meta.release_type = ReleaseType.INTERNAL
+                    self.package_meta.homebrew_channel = HomebrewChannel.RC
+        self.feedback_message = f"release_type: {self.package_meta.release_type.value}, homebrew_channel: {self.package_meta.homebrew_channel.value}"
 
         if self.log_once(
             "homebrew_channel_detected", self.package_meta.ephemeral.log_once_flags
         ):
-            self.logger.info(msg)
+            self.logger.info(
+                f"Hombrew release_type: {self.package_meta.release_type}, homebrew_channel: {self.package_meta.homebrew_channel}"
+            )
 
         return Status.SUCCESS
 
@@ -810,6 +853,10 @@ def __init__(
 
     def initialise(self) -> None:
         """Initialize by validating inputs and starting download task."""
+        if self.package_meta.ephemeral.is_version_acceptable is not None:
+            return
+
+        self.feedback_message = ""
         # Validate homebrew_channel is set
         if self.package_meta.homebrew_channel is None:
             self.logger.error("Homebrew channel is not set")
@@ -829,6 +876,10 @@ def initialise(self) -> None:
             self.logger.error("Release tag is not set")
             return
 
+        if self.package_meta.release_type is None:
+            self.logger.error("Package release type is not set")
+            return
+
         try:
             self.release_version = RedisVersion.parse(self.release_meta.tag)
             self.logger.debug(f"Parsed release version: {self.release_version}")
@@ -838,9 +889,9 @@ def initialise(self) -> None:
 
         # Determine which cask file to download based on channel
         if self.package_meta.homebrew_channel == HomebrewChannel.STABLE:
-            cask_file = "Casks/redis.rb"
+            cask_file = "zCasks/redis.rb"
         elif self.package_meta.homebrew_channel == HomebrewChannel.RC:
-            cask_file = "Casks/redis-rc.rb"
+            cask_file = "zCasks/redis-rc.rb"
         else:
             self.logger.error(
                 f"Unknown homebrew channel: {self.package_meta.homebrew_channel}"
@@ -860,14 +911,10 @@ def initialise(self) -> None:
 
     def update(self) -> Status:
         """Process downloaded cask file and classify version."""
-        try:
-            # Validate prerequisites
-            if self.package_meta.homebrew_channel is None:
-                return Status.FAILURE
-
-            if self.release_version is None:
-                return Status.FAILURE
+        if self.package_meta.ephemeral.is_version_acceptable is not None:
+            return Status.SUCCESS
 
+        try:
             assert self.task is not None
 
             # Wait for download to complete
@@ -882,8 +929,6 @@ def update(self) -> Status:
 
             # Parse version from cask file
             # Look for: version "X.Y.Z"
-            import re
-
             version_match = re.search(
                 r'^\s*version\s+"([^"]+)"', cask_content, re.MULTILINE
             )
@@ -905,27 +950,35 @@ def update(self) -> Status:
                 return Status.FAILURE
 
             # Compare versions: cask version >= release version means acceptable
-            if self.cask_version >= self.release_version:  # type: ignore[operator]
+            assert self.release_version is not None
+            self.package_meta.remote_version = str(self.cask_version)
+            log_prepend = ""
+            prepend_color = "green"
+            if self.release_version >= self.cask_version:
                 self.package_meta.ephemeral.is_version_acceptable = True
-                self.logger.info(
-                    f"[green]Version acceptable:[/green] cask {self.cask_version} >= release {self.release_version}"
+                self.feedback_message = (
+                    f"release {self.release_version} >= cask {self.cask_version}"
                 )
+                log_prepend = "Version acceptable: "
             else:
                 self.package_meta.ephemeral.is_version_acceptable = False
+                log_prepend = "Version NOT acceptable: "
+                prepend_color = "yellow"
+                self.feedback_message = (
+                    f"release {self.release_version} < cask {self.cask_version}"
+                )
+            if self.log_once(
+                "homebrew_version_classified",
+                self.package_meta.ephemeral.log_once_flags,
+            ):
                 self.logger.info(
-                    f"[yellow]Version not acceptable:[/yellow] cask {self.cask_version} < release {self.release_version}"
+                    f"[{prepend_color}]{log_prepend}{self.feedback_message}[/]"
                 )
-
             return Status.SUCCESS
 
         except Exception as e:
             return self.log_exception_and_return_failure(e)
 
-    def terminate(self, new_status: Status) -> None:
-        """Terminate the behavior."""
-        # TODO: Cancel task if needed
-        pass
-
 
 ### Conditions ###
 
@@ -1120,3 +1173,21 @@ def update(self) -> Status:
         if self.package_meta.ephemeral.force_rebuild:
             return Status.SUCCESS
         return Status.FAILURE
+
+
+class NeedToReleaseHomebrew(LoggingAction):
+    def __init__(
+        self,
+        name: str,
+        package_meta: HomebrewMeta,
+        release_meta: ReleaseMeta,
+        log_prefix: str = "",
+    ) -> None:
+        self.package_meta = package_meta
+        self.release_meta = release_meta
+        super().__init__(name=name, log_prefix=log_prefix)
+
+    def update(self) -> Status:
+        if self.package_meta.ephemeral.is_version_acceptable is True:
+            return Status.SUCCESS
+        return Status.FAILURE

src/redis_release/bht/composites.py

@@ -21,6 +21,7 @@
 
 from ..github_client_async import GitHubClientAsync
 from .behaviours import (
+    ClassifyHomebrewVersion,
     ExtractArtifactResult,
     GetWorkflowArtifactsList,
     IdentifyTargetRef,
@@ -32,7 +33,7 @@
 from .behaviours import TriggerWorkflow as TriggerWorkflow
 from .behaviours import UpdateWorkflowStatusUntilCompletion
 from .decorators import ConditionGuard, FlagGuard, StatusFlagGuard
-from .state import Package, PackageMeta, ReleaseMeta, Workflow
+from .state import HomebrewMeta, Package, PackageMeta, ReleaseMeta, Workflow
 
 
 class ParallelBarrier(Composite):
@@ -393,3 +394,27 @@ def __init__(
             guard_status=Status.FAILURE,
             log_prefix=log_prefix,
         )
+
+
+class ClassifyHomebrewVersionGuarded(StatusFlagGuard):
+    def __init__(
+        self,
+        name: str,
+        package_meta: HomebrewMeta,
+        release_meta: ReleaseMeta,
+        github_client: GitHubClientAsync,
+        log_prefix: str = "",
+    ) -> None:
+        super().__init__(
+            None if name == "" else name,
+            ClassifyHomebrewVersion(
+                "Classify Homebrew Version",
+                package_meta,
+                release_meta,
+                github_client,
+                log_prefix=log_prefix,
+            ),
+            package_meta.ephemeral,
+            "classify_remote_versions",
+            log_prefix=log_prefix,
+        )

src/redis_release/bht/state.py

@@ -22,7 +22,7 @@
 
 logger = logging.getLogger(__name__)
 
-SUPPORTED_STATE_VERSION = 2
+SUPPORTED_STATE_VERSION = 3
 
 
 class WorkflowEphemeral(BaseModel):
@@ -155,6 +155,11 @@ class HomebrewMeta(PackageMeta):
 
     serialization_hint: Literal["homebrew"] = "homebrew"  # type: ignore[assignment]
     homebrew_channel: Optional[HomebrewChannel] = None
+    # remote_version field is for status display only (e.g. to pair with
+    # classify_remote_versions flag) actual decision is based on
+    # ephemeral.is_version_acceptable which is reset on each run to always
+    # reflect recent remote version
+    remote_version: Optional[str] = None
     ephemeral: HomebrewMetaEphemeral = Field(default_factory=HomebrewMetaEphemeral)  # type: ignore[assignment]
 
 
@@ -163,6 +168,11 @@ class SnapMeta(PackageMeta):
 
     serialization_hint: Literal["snap"] = "snap"  # type: ignore[assignment]
     snap_risk_level: Optional[SnapRiskLevel] = None
+    # remote_version field is for status display only (e.g. to pair with
+    # classify_remote_versions flag) actual decision is based on
+    # ephemeral.is_version_acceptable which is reset on each run to always
+    # reflect recent remote version
+    remote_version: Optional[str] = None
     ephemeral: SnapMetaEphemeral = Field(default_factory=SnapMetaEphemeral)  # type: ignore[assignment]
 
 
@@ -203,7 +213,7 @@ class ReleaseMeta(BaseModel):
 class ReleaseState(BaseModel):
     """Release state adapted for behavior tree usage."""
 
-    version: int = 2
+    version: int = SUPPORTED_STATE_VERSION
     meta: ReleaseMeta = Field(default_factory=ReleaseMeta)
     packages: Dict[str, Package] = Field(default_factory=dict)
 

src/redis_release/bht/tree.py

@@ -19,7 +19,7 @@
 from py_trees.visitors import SnapshotVisitor
 from rich.text import Text
 
-from ..config import Config
+from ..config import Config, PackageConfig
 from ..github_client_async import GitHubClientAsync
 from ..models import PackageType, ReleaseArgs
 from ..state_display import print_state_table
@@ -42,7 +42,14 @@
     create_workflow_completion_ppa,
     create_workflow_success_ppa,
 )
-from .state import Package, PackageMeta, ReleaseMeta, ReleaseState, Workflow
+from .state import (
+    SUPPORTED_STATE_VERSION,
+    Package,
+    PackageMeta,
+    ReleaseMeta,
+    ReleaseState,
+    Workflow,
+)
 from .tree_factory import get_factory
 
 logger = logging.getLogger(__name__)
@@ -263,16 +270,24 @@ def create_by_name(self, name: str) -> Union[Selector, Sequence, Behaviour]:
             available = ", ".join(self.get_names())
             raise ValueError(f"Unknown name '{name}'. Available options: {available}")
 
+        config = Config(
+            version=SUPPORTED_STATE_VERSION,
+            packages={
+                "inspected": PackageConfig(
+                    repo="test/repo",
+                    package_type=self.package_type,
+                    build_workflow="build.yml",
+                    publish_workflow="publish.yml",
+                )
+            },
+        )
+        state = ReleaseState.from_config(config)
         # Create mock objects for PPA/branch creation
-        workflow = Workflow(workflow_file="test.yml", inputs={})
-        package_meta = PackageMeta(repo="redis/redis", ref="main")
-        release_meta = ReleaseMeta(tag=self.release_tag)
+        workflow = state.packages["inspected"].build
+        package_meta = state.packages["inspected"].meta
+        release_meta = state.meta
         github_client = GitHubClientAsync(token="dummy")
-        package = Package(
-            meta=package_meta,
-            build=workflow,
-            publish=Workflow(workflow_file="publish.yml", inputs={}),
-        )
+        package = state.packages["inspected"]
         log_prefix = "test"
 
         # Create and return the requested branch/PPA