superset-showtime 0.5.10__tar.gz → 0.5.11__tar.gz

{superset_showtime-0.5.10 → superset_showtime-0.5.11}/CLAUDE.md

@@ -164,3 +164,68 @@ showtime list --status running
 showtime start 1234 --sha abc123f
 showtime stop 1234 --force
 ```
+
+## Race Condition Handling
+
+### Problem Description
+
+Double triggers can create race conditions in two scenarios:
+
+1. **Same SHA conflicts**: User pushes commit abc123f twice, creating 2 workflows for identical SHA
+2. **Stale locks**: Jobs crash or get killed, leaving environments stuck in "building/deploying" state indefinitely
+
+### Current Atomic Claim Mechanism
+
+The `PullRequest._atomic_claim()` method handles basic conflicts by:
+1. Checking if target SHA is already in progress states (`building`, `built`, `deploying`)  
+2. Removing trigger labels atomically
+3. Setting building state immediately
+
+**Limitations**:
+- No distinction between valid locks and stale locks (>1 hour old)
+- `refresh_labels()` is expensive (~500ms) but called on every claim attempt
+- Crashed jobs can leave permanent locks that block future deployments
+
+### Proposed Smart Lock Detection Strategy
+
+**Two-phase approach optimizing for the common case**:
+
+#### Phase 1: Fast Path (95% of calls, ~5ms)
+```python
+def can_start_job(self, target_sha: str, action: str, use_cached: bool = True) -> tuple[bool, str]:
+    """Fast check using cached self.labels"""
+    # Check cached labels for basic conflicts
+    # Returns (can_start, reason)
+```
+
+#### Phase 2: Recovery Path (5% of calls, ~500ms) 
+```python
+def double_check_and_cleanup_stale_locks(self, target_sha: str, stale_hours: int = 1, dry_run: bool = False) -> bool:
+    """Expensive: refresh labels, detect stale locks (>1h), clean them up"""
+    # Only called when fast path detects potential conflict
+    # Refreshes labels, checks timestamps, cleans stale AWS resources + GitHub labels
+```
+
+#### Enhanced Atomic Claim Logic
+```python
+def _atomic_claim(self, target_sha: str, action: str, dry_run: bool = False) -> bool:
+    # 1. Fast check with cached labels
+    can_start, reason = self.can_start_job(target_sha, action, use_cached=True)
+    
+    if not can_start:
+        # 2. Expensive double-check and cleanup
+        can_start = self.double_check_and_cleanup_stale_locks(target_sha, stale_hours=1, dry_run=dry_run)
+    
+    # 3. Continue with existing trigger removal + building setup
+```
+
+### Key Benefits
+
+- **Performance**: 95% fast path using cached labels (~5ms vs ~500ms)
+- **Reliability**: Automatic recovery from stale locks (crashed/killed jobs)
+- **Clarity**: Clear distinction between valid conflicts and recoverable states
+- **Safety**: Only cleans locks older than configurable threshold (default: 1 hour)
+
+### Implementation Notes
+
+This enhancement can be implemented when race conditions become problematic in practice. The current trigger removal mechanism already handles most same-SHA conflicts effectively due to the speed of GitHub label operations.

{superset_showtime-0.5.10 → superset_showtime-0.5.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superset-showtime
-Version: 0.5.10
+Version: 0.5.11
 Summary: 🎪 Apache Superset ephemeral environment management with circus tent emoji state tracking
 Project-URL: Homepage, https://github.com/apache/superset-showtime
 Project-URL: Documentation, https://superset-showtime.readthedocs.io/

{superset_showtime-0.5.10 → superset_showtime-0.5.11}/showtime/__init__.py

@@ -4,7 +4,7 @@
 Circus tent emoji state tracking for Apache Superset ephemeral environments.
 """
 
-__version__ = "0.5.10"
+__version__ = "0.5.11"
 __author__ = "Maxime Beauchemin"
 __email__ = "maximebeauchemin@gmail.com"
 

{superset_showtime-0.5.10 → superset_showtime-0.5.11}/showtime/core/git_validation.py

@@ -50,7 +50,7 @@ def is_git_repository(path: str = ".") -> bool:
 def validate_required_sha(required_sha: Optional[str] = None) -> Tuple[bool, Optional[str]]:
     """
     Validate that the required SHA exists in the current Git repository.
-    Tries to fetch the SHA from origin if validation fails in a shallow clone.
+    Uses GitHub API for reliable validation in shallow clone environments.
 
     Args:
         required_sha: SHA to validate (default: REQUIRED_SHA constant)
@@ -60,55 +60,90 @@ def validate_required_sha(required_sha: Optional[str] = None) -> Tuple[bool, Opt
         - (True, None) if validation passes
         - (False, error_message) if validation fails
     """
-    if Repo is None:
-        return False, "GitPython not available for SHA validation"
-
     sha_to_check = required_sha or REQUIRED_SHA
     if not sha_to_check:
         return True, None  # No requirement set
 
+    # Try GitHub API validation first (works in shallow clones)
     try:
-        repo = Repo(".")
+        return _validate_sha_via_github_api(sha_to_check)
+    except Exception as e:
+        print(f"⚠️ GitHub API validation failed: {e}")
+
+    # Fallback to Git validation for non-GitHub origins
+    if Repo is None:
+        print("⚠️ GitPython not available, skipping SHA validation")
+        return True, None
 
-        # First attempt: Search for SHA in git log (has to work in shallow clones where merge_base fails)
+    try:
+        repo = Repo(".")
         is_valid, error = _validate_sha_in_log(repo, sha_to_check)
         if is_valid:
             return True, None
+        else:
+            print(f"⚠️ Git validation failed: {error}")
+            return True, None  # Allow operation to continue
 
-        # If validation failed, check if we're in a shallow clone and try fetching
-        try:
-            is_shallow = repo.git.rev_parse("--is-shallow-repository") == "true"
-            if is_shallow:
-                try:
-                    print(f"🌊 Shallow clone detected, attempting to fetch {sha_to_check[:7]}...")
-                    repo.git.fetch("origin", sha_to_check)
-
-                    # Retry validation after fetch
-                    is_valid_after_fetch, error_after_fetch = _validate_sha_in_log(
-                        repo, sha_to_check
-                    )
-                    if is_valid_after_fetch:
-                        print(f"✅ Successfully fetched and validated {sha_to_check[:7]}")
-                        return True, None
-                    else:
-                        return False, error_after_fetch
-
-                except Exception as fetch_error:
-                    return False, (
-                        f"Required commit {sha_to_check} not found in shallow clone. "
-                        f"Failed to fetch from origin: {fetch_error}"
-                    )
-            else:
-                return False, error
+    except InvalidGitRepositoryError:
+        print("⚠️ Not a Git repository, skipping SHA validation")
+        return True, None
+    except Exception as e:
+        print(f"⚠️ Git validation error: {e}")
+        return True, None
 
-        except Exception:
-            # If shallow check fails, return original error
-            return False, error
 
-    except InvalidGitRepositoryError:
-        return False, "Current directory is not a Git repository"
+def _validate_sha_via_github_api(required_sha: str) -> Tuple[bool, Optional[str]]:
+    """Validate SHA using GitHub API - works reliably in shallow clones"""
+    try:
+        import httpx
+        from git import Repo
+
+        from .github import GitHubInterface
+
+        # Get current SHA from Git
+        repo = Repo(".")
+        current_sha = repo.head.commit.hexsha
+
+        # Use existing GitHubInterface (handles all the setup/token detection)
+        github = GitHubInterface()
+
+        # 1. Check if required SHA exists
+        commit_url = f"{github.base_url}/repos/{github.org}/{github.repo}/commits/{required_sha}"
+
+        with httpx.Client() as client:
+            response = client.get(commit_url, headers=github.headers)
+            if response.status_code == 404:
+                return False, f"Required SHA {required_sha[:7]} not found in repository"
+            response.raise_for_status()
+
+        # 2. Compare SHAs to verify ancestry
+        compare_url = f"{github.base_url}/repos/{github.org}/{github.repo}/compare/{required_sha}...{current_sha}"
+
+        with httpx.Client() as client:
+            response = client.get(compare_url, headers=github.headers)
+            if response.status_code == 404:
+                return (
+                    False,
+                    f"Current branch does not include required SHA {required_sha[:7]}. Please rebase onto main.",
+                )
+            response.raise_for_status()
+
+            data = response.json()
+            status = data.get("status")
+
+            # If status is 'ahead' or 'identical', required SHA is ancestor (good)
+            # If status is 'behind', current is behind required (bad)
+            if status in ["ahead", "identical"]:
+                return True, None
+            else:
+                return (
+                    False,
+                    f"Current branch does not include required SHA {required_sha[:7]}. Please rebase onto main.",
+                )
+
     except Exception as e:
-        return False, f"Git validation error: {e}"
+        # Re-raise to be caught by the caller for proper fallback handling
+        raise Exception(f"GitHub API validation error: {e}") from e
 
 
 def _validate_sha_in_log(repo: "Repo", sha_to_check: str) -> Tuple[bool, Optional[str]]: