Rework ephemeral

Author: Peter-Sh

src/redis_release/bht/state.py

@@ -22,15 +22,46 @@
 
 
 class WorkflowEphemeral(BaseModel):
-    """Ephemeral workflow state that is not persisted."""
+    """Ephemeral workflow state. Reset on each run.
 
-    trigger_failed: bool = False
-    trigger_attempted: bool = False
-    identify_failed: bool = False
-    timed_out: bool = False
-    artifacts_download_failed: bool = False
-    extract_result_failed: bool = False
-    log_once_flags: Dict[str, bool] = Field(default_factory=dict)
+    Each workflow step has a pair of fields indicating the step status:
+    One ephemeral field is set when the step is attempted. It may have three states:
+    - `None` (default): Step has not been attempted
+    - `True`: Step has been attempted and failed
+    - `False`: Step has been attempted and succeeded
+
+    Ephemeral fields are reset on each run. Their values are persisted but only until
+    next run is started.
+    So they indicate either current (if run is in progress) or last run state.
+
+    The other field indicates the step result, it may either have some value or be empty.
+
+    For example for trigger step we have `trigger_failed` ephemeral
+    and `triggered_at` result fields.
+
+    Each step may be in one of the following states:
+        Not started
+        Failed
+        Succeeded or OK
+        Incorrect (this shouln't happen)
+
+    The following decision table show how step status is determined for trigger step.
+    In general this logic is used to display release state table.
+
+    tigger_failed -> | None (default) |   True    |   False   |
+    triggered_at:    |                |           |           |
+       None          |   Not started  |   Failed  | Incorrect |
+      Has value      |       OK       | Incorrect |     OK    |
+
+    """
+
+    trigger_failed: Optional[bool] = None
+    trigger_attempted: Optional[bool] = None
+    identify_failed: Optional[bool] = None
+    timed_out: Optional[bool] = None
+    artifacts_download_failed: Optional[bool] = None
+    extract_result_failed: Optional[bool] = None
+    log_once_flags: Dict[str, bool] = Field(default_factory=dict, exclude=True)
 
 
 class Workflow(BaseModel):
@@ -47,17 +78,18 @@ class Workflow(BaseModel):
     conclusion: Optional[WorkflowConclusion] = None
     artifacts: Optional[Dict[str, Any]] = None
     result: Optional[Dict[str, Any]] = None
-    ephemeral: WorkflowEphemeral = Field(
-        default_factory=WorkflowEphemeral, exclude=True
-    )
+    ephemeral: WorkflowEphemeral = Field(default_factory=WorkflowEphemeral)
 
 
 class PackageMetaEphemeral(BaseModel):
-    """Ephemeral package metadata that is not persisted."""
+    """Ephemeral package metadata. Reset on each run.
+
+    See WorkflowEphemeral for more details.
+    """
 
     force_rebuild: bool = False
     identify_ref_failed: bool = False
-    log_once_flags: Dict[str, bool] = Field(default_factory=dict)
+    log_once_flags: Dict[str, bool] = Field(default_factory=dict, exclude=True)
 
 
 class PackageMeta(BaseModel):
@@ -67,9 +99,7 @@ class PackageMeta(BaseModel):
     repo: str = ""
     ref: Optional[str] = None
     publish_internal_release: bool = False
-    ephemeral: PackageMetaEphemeral = Field(
-        default_factory=PackageMetaEphemeral, exclude=True
-    )
+    ephemeral: PackageMetaEphemeral = Field(default_factory=PackageMetaEphemeral)
 
 
 class Package(BaseModel):
@@ -81,19 +111,20 @@ class Package(BaseModel):
 
 
 class ReleaseMetaEphemeral(BaseModel):
-    """Ephemeral release metadata that is not persisted."""
+    """Ephemeral release metadata. Reset on each run.
+
+    See WorkflowEphemeral for more details.
+    """
 
-    log_once_flags: Dict[str, bool] = Field(default_factory=dict)
+    log_once_flags: Dict[str, bool] = Field(default_factory=dict, exclude=True)
 
 
 class ReleaseMeta(BaseModel):
     """Metadata for the release."""
 
     tag: Optional[str] = None
     release_type: Optional[ReleaseType] = None
-    ephemeral: ReleaseMetaEphemeral = Field(
-        default_factory=ReleaseMetaEphemeral, exclude=True
-    )
+    ephemeral: ReleaseMetaEphemeral = Field(default_factory=ReleaseMetaEphemeral)
 
 
 class ReleaseState(BaseModel):

src/redis_release/state_manager.py

@@ -248,9 +248,25 @@ def load(self) -> Optional[ReleaseState]:
             return None
 
         state = ReleaseState(**state_data)
+
+        # Reset ephemeral fields to defaults if not in read-only mode
+        if not self.read_only:
+            self._reset_ephemeral_fields(state)
+
         self.last_dump = state.model_dump_json(indent=2)
         return state
 
+    def _reset_ephemeral_fields(self, state: ReleaseState) -> None:
+        """Reset ephemeral fields to defaults (except log_once_flags which are always reset)."""
+        # Reset release meta ephemeral
+        state.meta.ephemeral = state.meta.ephemeral.__class__()
+
+        # Reset package ephemeral fields
+        for package in state.packages.values():
+            package.meta.ephemeral = package.meta.ephemeral.__class__()
+            package.build.ephemeral = package.build.ephemeral.__class__()
+            package.publish.ephemeral = package.publish.ephemeral.__class__()
+
     def sync(self) -> None:
         """Save state to storage backend if changed since last sync."""
         if self.read_only:

src/tests/test_state.py

@@ -304,36 +304,39 @@ def test_ephemeral_field_can_be_modified(self) -> None:
         assert workflow.ephemeral.timed_out is True
 
     def test_ephemeral_field_not_serialized_to_json(self) -> None:
-        """Test that ephemeral field is excluded from JSON serialization."""
+        """Test that ephemeral field is serialized but log_once_flags are excluded."""
         workflow = Workflow(workflow_file="test.yml")
         workflow.ephemeral.trigger_failed = True
         workflow.ephemeral.timed_out = True
+        workflow.ephemeral.log_once_flags["test_flag"] = True
 
         # Serialize to JSON
         json_str = workflow.model_dump_json()
         json_data = json.loads(json_str)
 
-        # Verify ephemeral field is not in JSON
-        assert "ephemeral" not in json_data
-        assert "trigger_failed" not in json_data
-        assert "timed_out" not in json_data
+        # Verify ephemeral field IS in JSON (except log_once_flags)
+        assert "ephemeral" in json_data
+        assert json_data["ephemeral"]["trigger_failed"] is True
+        assert json_data["ephemeral"]["timed_out"] is True
+        assert "log_once_flags" not in json_data["ephemeral"]
 
         # Verify other fields are present
         assert "workflow_file" in json_data
         assert json_data["workflow_file"] == "test.yml"
 
     def test_ephemeral_field_not_in_model_dump(self) -> None:
-        """Test that ephemeral field is excluded from model_dump."""
+        """Test that ephemeral field is in model_dump but log_once_flags are excluded."""
         workflow = Workflow(workflow_file="test.yml")
         workflow.ephemeral.trigger_failed = True
+        workflow.ephemeral.log_once_flags["test_flag"] = True
 
         # Get dict representation
         data = workflow.model_dump()
 
-        # Verify ephemeral field is not in dict
-        assert "ephemeral" not in data
-        assert "trigger_failed" not in data
-        assert "timed_out" not in data
+        # Verify ephemeral field IS in dict (except log_once_flags)
+        assert "ephemeral" in data
+        assert data["ephemeral"]["trigger_failed"] is True
+        assert "log_once_flags" not in data["ephemeral"]
 
     def test_ephemeral_field_initialized_on_deserialization(self) -> None:
         """Test that ephemeral field is initialized when loading from JSON."""
@@ -347,7 +350,7 @@ def test_ephemeral_field_initialized_on_deserialization(self) -> None:
         assert workflow.ephemeral.timed_out is False
 
     def test_release_state_ephemeral_not_serialized(self) -> None:
-        """Test that ephemeral fields are not serialized in ReleaseState."""
+        """Test that ephemeral fields are serialized but log_once_flags are excluded."""
         config = Config(
             version=1,
             packages={
@@ -365,19 +368,22 @@ def test_release_state_ephemeral_not_serialized(self) -> None:
         # Modify ephemeral fields
         state.packages["test-package"].build.ephemeral.trigger_failed = True
         state.packages["test-package"].publish.ephemeral.timed_out = True
+        state.packages["test-package"].build.ephemeral.log_once_flags["test"] = True
 
         # Serialize to JSON
         json_str = state.model_dump_json()
         json_data = json.loads(json_str)
 
-        # Verify ephemeral fields are not in JSON
+        # Verify ephemeral fields ARE in JSON (except log_once_flags)
         build_workflow = json_data["packages"]["test-package"]["build"]
         publish_workflow = json_data["packages"]["test-package"]["publish"]
 
-        assert "ephemeral" not in build_workflow
-        assert "trigger_failed" not in build_workflow
-        assert "ephemeral" not in publish_workflow
-        assert "timed_out" not in publish_workflow
+        assert "ephemeral" in build_workflow
+        assert build_workflow["ephemeral"]["trigger_failed"] is True
+        assert "log_once_flags" not in build_workflow["ephemeral"]
+        assert "ephemeral" in publish_workflow
+        assert publish_workflow["ephemeral"]["timed_out"] is True
+        assert "log_once_flags" not in publish_workflow["ephemeral"]
 
 
 class TestReleaseMeta:
@@ -449,7 +455,7 @@ def test_force_rebuild_field_can_be_modified(self) -> None:
         assert state.packages["test-package"].meta.ephemeral.force_rebuild is True
 
     def test_ephemeral_not_serialized(self) -> None:
-        """Test that ephemeral field is not serialized to JSON."""
+        """Test that ephemeral field is serialized but log_once_flags are excluded."""
         config = Config(
             version=1,
             packages={
@@ -464,12 +470,21 @@ def test_ephemeral_not_serialized(self) -> None:
 
         state = ReleaseState.from_config(config)
         state.packages["test-package"].meta.ephemeral.force_rebuild = True
+        state.packages["test-package"].meta.ephemeral.log_once_flags["test"] = True
 
         json_str = state.model_dump_json()
         json_data = json.loads(json_str)
 
-        assert "ephemeral" not in json_data["packages"]["test-package"]["meta"]
-        assert "force_rebuild" not in json_data["packages"]["test-package"]["meta"]
+        # Ephemeral field IS serialized (except log_once_flags)
+        assert "ephemeral" in json_data["packages"]["test-package"]["meta"]
+        assert (
+            json_data["packages"]["test-package"]["meta"]["ephemeral"]["force_rebuild"]
+            is True
+        )
+        assert (
+            "log_once_flags"
+            not in json_data["packages"]["test-package"]["meta"]["ephemeral"]
+        )
 
 
 class TestStateSyncerWithArgs: