Add publish phase

Extract workflow executor into separate classes
Update what is success definition
Remove force_rebuild from the state

Author: Peter-Sh

src/redis_release/cli.py

@@ -111,9 +111,12 @@ def status(
         table = Table(title=f"Release Status: {tag}")
         table.add_column("Package", style="cyan")
         table.add_column("Build Status", style="magenta")
-        table.add_column("Artifacts", style="blue")
+        table.add_column("Publish Status", style="green")
+        table.add_column("Build Artifacts", style="blue")
+        table.add_column("Publish Artifacts", style="yellow")
 
         for pkg_type, pkg_state in state.packages.items():
+            # Build status
             if not pkg_state.build_completed:
                 build_status = "[blue]In Progress[/blue]"
             elif pkg_state.build_workflow and pkg_state.build_workflow.conclusion:
@@ -126,12 +129,32 @@ def status(
             else:
                 build_status = "[yellow]Cancelled[/yellow]"
 
-            if pkg_state.artifacts:
-                artifacts = f"[green]{len(pkg_state.artifacts)} artifacts[/green]"
+            # Publish status
+            if not pkg_state.publish_completed:
+                publish_status = "[blue]In Progress[/blue]" if pkg_state.publish_workflow else "[dim]Not Started[/dim]"
+            elif pkg_state.publish_workflow and pkg_state.publish_workflow.conclusion:
+                if pkg_state.publish_workflow.conclusion.value == "success":
+                    publish_status = "[green]Success[/green]"
+                elif pkg_state.publish_workflow.conclusion.value == "failure":
+                    publish_status = "[red]Failed[/red]"
+                else:
+                    publish_status = "[yellow]Cancelled[/yellow]"
+            else:
+                publish_status = "[yellow]Cancelled[/yellow]"
+
+            # Build artifacts
+            if pkg_state.build_artifacts:
+                build_artifacts = f"[green]{len(pkg_state.build_artifacts)}[/green]"
+            else:
+                build_artifacts = "[dim]None[/dim]"
+
+            # Publish artifacts
+            if pkg_state.publish_artifacts:
+                publish_artifacts = f"[green]{len(pkg_state.publish_artifacts)}[/green]"
             else:
-                artifacts = "[dim]None[/dim]"
+                publish_artifacts = "[dim]None[/dim]"
 
-            table.add_row(pkg_type.value, build_status, artifacts)
+            table.add_row(pkg_type.value, build_status, publish_status, build_artifacts, publish_artifacts)
 
         console.print(table)
 
@@ -146,16 +169,6 @@ def status(
                     f"  Docker repo: [cyan]{state.docker_repo_commit[:8]}[/cyan]"
                 )
 
-        if state.is_build_phase_complete():
-            console.print("[green]Release is complete![/green]")
-        elif state.has_build_failures():
-            console.print(
-                "[red]Release failed - build phase completed with errors[/red]"
-            )
-        elif state.is_build_phase_finished():
-            console.print("[yellow]Release completed but not successful[/yellow]")
-        else:
-            console.print("[blue]Building Docker image...[/blue]")
 
     except Exception as e:
         console.print(f"[red] Failed to get status: {e}[/red]")

src/redis_release/github_client.py

@@ -264,12 +264,21 @@ def get_workflow_artifacts(self, repo: str, run_id: int) -> Dict[str, Dict]:
                     "size_in_bytes": 1048576,
                     "digest": "sha256:mock-digest"
                 },
-                "mock-artifact": {
+                "release_info": {
                     "id": 67890,
                     "archive_download_url": f"https://api.github.com/repos/{repo}/actions/artifacts/67890/zip",
                     "created_at": "2023-01-01T00:00:00Z",
                     "expires_at": "2023-01-31T00:00:00Z",
                     "updated_at": "2023-01-01T00:00:00Z",
+                    "size_in_bytes": 2097152,
+                    "digest": "sha256:mock-digest-info"
+                },
+                "mock-artifact": {
+                    "id": 11111,
+                    "archive_download_url": f"https://api.github.com/repos/{repo}/actions/artifacts/11111/zip",
+                    "created_at": "2023-01-01T00:00:00Z",
+                    "expires_at": "2023-01-31T00:00:00Z",
+                    "updated_at": "2023-01-01T00:00:00Z",
                     "size_in_bytes": 2048576,
                     "digest": "sha256:mock-digest-2"
                 }
@@ -322,31 +331,33 @@ def get_workflow_artifacts(self, repo: str, run_id: int) -> Dict[str, Dict]:
             console.print(f"[red]Failed to get artifacts: {e}[/red]")
             return {}
 
-    def extract_release_handle(self, repo: str, artifacts: Dict[str, Dict]) -> Optional[Dict[str, Any]]:
-        """Extract release_handle JSON from artifacts.
+    def extract_result(self, repo: str, artifacts: Dict[str, Dict], artifact_name: str, json_file_name: str) -> Optional[Dict[str, Any]]:
+        """Extract JSON result from artifacts.
 
         Args:
             repo: Repository name
             artifacts: Dictionary of artifacts from get_workflow_artifacts
+            artifact_name: Name of the artifact to extract from
+            json_file_name: Name of the JSON file within the artifact
 
         Returns:
-            Parsed JSON content from release_handle.json file, or None if not found
+            Parsed JSON content from the specified file, or None if not found
         """
-        if "release_handle" not in artifacts:
-            console.print("[yellow]No release_handle artifact found[/yellow]")
+        if artifact_name not in artifacts:
+            console.print(f"[yellow]No {artifact_name} artifact found[/yellow]")
             return None
 
-        release_handle_artifact = artifacts["release_handle"]
-        artifact_id = release_handle_artifact.get("id")
+        target_artifact = artifacts[artifact_name]
+        artifact_id = target_artifact.get("id")
 
         if not artifact_id:
-            console.print("[red]release_handle artifact has no ID[/red]")
+            console.print(f"[red]{artifact_name} artifact has no ID[/red]")
             return None
 
-        console.print(f"[blue]Extracting release_handle from artifact {artifact_id}[/blue]")
+        console.print(f"[blue]Extracting {json_file_name} from artifact {artifact_id}[/blue]")
 
         if self.dry_run:
-            console.print("[yellow]   (DRY RUN - returning mock release_handle)[/yellow]")
+            console.print(f"[yellow]   (DRY RUN - returning mock {json_file_name})[/yellow]")
             return {
                 "mock": True,
                 "version": "1.0.0",
@@ -356,10 +367,10 @@ def extract_release_handle(self, repo: str, artifacts: Dict[str, Dict]) -> Optio
                 }
             }
 
-        # Download the artifact and extract release_handle.json
-        download_url = release_handle_artifact.get("archive_download_url")
+        # Download the artifact and extract JSON file
+        download_url = target_artifact.get("archive_download_url")
         if not download_url:
-            console.print("[red]release_handle artifact has no download URL[/red]")
+            console.print(f"[red]{artifact_name} artifact has no download URL[/red]")
             return None
 
         headers = {
@@ -373,27 +384,41 @@ def extract_release_handle(self, repo: str, artifacts: Dict[str, Dict]) -> Optio
             response = requests.get(download_url, headers=headers, timeout=30)
             response.raise_for_status()
 
-            # Extract release_handle.json from the zip
+            # Extract JSON file from the zip
             import zipfile
             import io
 
             with zipfile.ZipFile(io.BytesIO(response.content)) as zip_file:
-                if "release_handle.json" in zip_file.namelist():
-                    with zip_file.open("release_handle.json") as json_file:
-                        release_handle_data = json.load(json_file)
-                        console.print("[green]Successfully extracted release_handle.json[/green]")
-                        return release_handle_data
+                if json_file_name in zip_file.namelist():
+                    with zip_file.open(json_file_name) as json_file:
+                        result_data = json.load(json_file)
+                        console.print(f"[green]Successfully extracted {json_file_name}[/green]")
+                        return result_data
                 else:
-                    console.print("[red]release_handle.json not found in artifact[/red]")
+                    console.print(f"[red]{json_file_name} not found in artifact[/red]")
                     return None
 
         except requests.exceptions.RequestException as e:
-            console.print(f"[red]Failed to download release_handle artifact: {e}[/red]")
+            console.print(f"[red]Failed to download {artifact_name} artifact: {e}[/red]")
             return None
         except (zipfile.BadZipFile, json.JSONDecodeError, KeyError) as e:
-            console.print(f"[red]Failed to extract release_handle.json: {e}[/red]")
+            console.print(f"[red]Failed to extract {json_file_name}: {e}[/red]")
             return None
 
+    def extract_release_handle(self, repo: str, artifacts: Dict[str, Dict]) -> Optional[Dict[str, Any]]:
+        """Extract release_handle JSON from artifacts.
+
+        This is a backward compatibility wrapper around extract_result.
+
+        Args:
+            repo: Repository name
+            artifacts: Dictionary of artifacts from get_workflow_artifacts
+
+        Returns:
+            Parsed JSON content from release_handle.json file, or None if not found
+        """
+        return self.extract_result(repo, artifacts, "release_handle", "release_handle.json")
+
     def _get_recent_workflow_runs(
         self, repo: str, workflow_file: str, limit: int = 10
     ) -> List[WorkflowRun]:

src/redis_release/models.py

@@ -53,14 +53,31 @@ class PackageState(BaseModel):
 
     package_type: PackageType
     build_workflow: Optional[WorkflowRun] = None
-    artifacts: Dict[str, Dict[str, Any]] = Field(default_factory=dict)
+    build_artifacts: Dict[str, Dict[str, Any]] = Field(default_factory=dict)
     release_handle: Optional[Dict[str, Any]] = None
     build_completed: bool = False
 
     # Publish phase information
     publish_workflow: Optional[WorkflowRun] = None
     publish_completed: bool = False
     publish_info: Optional[Dict[str, Any]] = None
+    publish_artifacts: Dict[str, Dict[str, Any]] = Field(default_factory=dict)
+
+    def is_build_phase_successful(self) -> bool:
+        """Check if build workflow is completed successfully."""
+        return (
+            self.build_completed
+            and self.build_workflow is not None
+            and self.build_workflow.conclusion == WorkflowConclusion.SUCCESS
+        )
+
+    def is_publish_phase_successful(self) -> bool:
+        """Check if publish workflow is completed successfully."""
+        return (
+            self.publish_completed
+            and self.publish_workflow is not None
+            and self.publish_workflow.conclusion == WorkflowConclusion.SUCCESS
+        )
 
 
 class ReleaseState(BaseModel):
@@ -76,14 +93,12 @@ class ReleaseState(BaseModel):
     redis_tag_commit: Optional[str] = None  # Redis tag commit hash
     docker_repo_commit: Optional[str] = None  # Docker repo latest commit hash
 
-    def is_build_phase_complete(self) -> bool:
+    def is_build_successful(self) -> bool:
         """Check if all build workflows are completed successfully."""
         if not self.packages:
             return False
         return all(
-            pkg.build_completed
-            and pkg.build_workflow
-            and pkg.build_workflow.conclusion == WorkflowConclusion.SUCCESS
+            pkg.is_build_phase_successful()
             for pkg in self.packages.values()
         )
 
@@ -104,14 +119,12 @@ def has_build_failures(self) -> bool:
             for pkg in self.packages.values()
         )
 
-    def is_publish_phase_complete(self) -> bool:
+    def is_publish_successful(self) -> bool:
         """Check if all publish workflows are completed successfully."""
         if not self.packages:
             return False
         return all(
-            pkg.publish_completed
-            and pkg.publish_workflow
-            and pkg.publish_workflow.conclusion == WorkflowConclusion.SUCCESS
+            pkg.is_publish_phase_successful()
             for pkg in self.packages.values()
         )