half-orm-dev 1.0.0a29__tar.gz → 1.0.0a31__tar.gz

{half_orm_dev-1.0.0a29/half_orm_dev.egg-info → half_orm_dev-1.0.0a31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 1.0.0a29
+Version: 1.0.0a31
 Summary: half_orm development Framework.
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License-Expression: GPL-3.0-or-later

{half_orm_dev-1.0.0a29 → half_orm_dev-1.0.0a31}/half_orm_dev/bootstrap_manager.py

@@ -18,7 +18,7 @@ from pathlib import Path
 from typing import List, Set, Tuple, Optional, TYPE_CHECKING
 
 from half_orm_dev.file_executor import (
-    execute_sql_file, execute_python_file, FileExecutionError
+    execute_sql_file, execute_python_bootstrap, FileExecutionError
 )
 
 if TYPE_CHECKING:
@@ -180,7 +180,11 @@ class BootstrapManager:
             if file_path.suffix == '.sql':
                 execute_sql_file(file_path, self._repo.database.model)
             elif file_path.suffix == '.py':
-                output = execute_python_file(file_path, cwd=self._bootstrap_dir)
+                output = execute_python_bootstrap(
+                    file_path,
+                    model=self._repo.database.model,
+                    cwd=self._bootstrap_dir
+                )
                 if output:
                     click.echo(f"    Output: {output}")
             else:

{half_orm_dev-1.0.0a29 → half_orm_dev-1.0.0a31}/half_orm_dev/cli/commands/__init__.py

@@ -10,15 +10,15 @@ from .init import init
 from .clone import clone
 from .patch import patch
 from .release import release
-from .update import update
 from .upgrade import upgrade
 from .check import check
 from .set_git_origin import set_git_origin
 from .migrate import migrate
 from .revert_migration import revert_migration
 from .bootstrap import bootstrap
+from .rollback import rollback
+from .recover import recover
 from .todo import apply_release
-from .todo import rollback
 
 # ♻️ Adapted existing commands
 from .todo import sync_package    # Unchanged
@@ -31,7 +31,6 @@ ALL_COMMANDS = {
     'clone': clone,
     'patch': patch,
     'release': release,
-    'update': update,          # Adapted for production
     'upgrade': upgrade,          # Adapted for production
     'check': check,            # Project health check and updates
     'set-git-origin': set_git_origin,  # Update git remote origin URL
@@ -43,6 +42,7 @@ ALL_COMMANDS = {
 
     # 🚧 Emergency workflow (stubs)
     'rollback': rollback,
+    'recover': recover,
 
     # ♻️ Adapted commands
     'sync-package': sync_package, # Unchanged
@@ -60,6 +60,7 @@ __all__ = [
     'migrate',
     'bootstrap',
     'rollback',
+    'recover',
     # Adapted commands
     'sync_package',
     'ALL_COMMANDS'

half_orm_dev-1.0.0a31/half_orm_dev/cli/commands/recover.py

@@ -0,0 +1,46 @@
+"""
+Recover command - Complete or clean up an interrupted sync operation.
+"""
+
+import sys
+import click
+from half_orm_dev.repo import Repo
+from half_orm import utils
+
+
+@click.command()
+def recover() -> None:
+    """Complete or clean up a sync interrupted by a crash or network failure.
+
+    Reads .git/hop-sync-lock to verify ownership of the interrupted operation,
+    then either pushes branches whose sync commit completed (Phase 2 finish)
+    or restores clean state for branches interrupted mid-commit (Phase 1 cleanup).
+    Releases the distributed lock when done.
+    """
+    repo = Repo()
+    result = repo.recover()
+
+    if result['errors'] and not result['pushed_branches'] and not result['cleaned_branches']:
+        for error in result['errors']:
+            click.echo(utils.Color.red(f"Error: {error}"), err=True)
+        sys.exit(1)
+
+    if result['lock_tag']:
+        click.echo(f"Recovering from interrupted sync (lock: {result['lock_tag']})")
+
+    if result['pushed_branches']:
+        for branch in result['pushed_branches']:
+            click.echo(f"  Pushed:   {branch}")
+
+    if result['cleaned_branches']:
+        for branch in result['cleaned_branches']:
+            click.echo(f"  Cleaned:  {branch}")
+
+    if not result['pushed_branches'] and not result['cleaned_branches']:
+        click.echo("Nothing to recover — lock released.")
+
+    if result['errors']:
+        for error in result['errors']:
+            click.echo(utils.Color.yellow(f"Warning: {error}"), err=True)
+
+    click.echo(utils.Color.green("Recovery complete."))

half_orm_dev-1.0.0a31/half_orm_dev/cli/commands/rollback.py

@@ -0,0 +1,103 @@
+"""
+Rollback command - Restore production to a previous version.
+
+Restores the database from a stored snapshot and checks out the
+corresponding immutable ho-prod-X.Y.Z branch.
+"""
+
+import click
+from half_orm_dev.repo import Repo
+from half_orm_dev.release_manager import ReleaseManagerError
+from half_orm import utils
+
+
+@click.command()
+@click.option(
+    '--to-version', '-t',
+    type=str,
+    default=None,
+    help='Target version (default: previous version)'
+)
+@click.option(
+    '--yes', '-y',
+    is_flag=True,
+    help='Skip confirmation prompt'
+)
+def rollback(to_version: str, yes: bool) -> None:
+    """
+    Rollback production to a previous version.
+
+    Restores the database from the snapshot created before the last upgrade
+    and checks out the corresponding ho-prod-X.Y.Z branch.
+
+    Requirements:
+      • Must be on a ho-prod-X.Y.Z branch
+      • Snapshot must exist for the target version
+
+    \b
+    Examples:
+        # Rollback to previous version (default)
+        half_orm dev rollback
+
+        # Rollback to a specific version
+        half_orm dev rollback --to-version 0.2.23
+    """
+    try:
+        repo = Repo()
+        mgr = repo.release_manager
+
+        current_version = repo.database.last_release_s
+        available = mgr._list_rollback_versions()
+
+        if not available:
+            click.echo(utils.Color.red("❌ No snapshots available for rollback."), err=True)
+            raise click.Abort()
+
+        # Resolve default target
+        target = to_version
+        if target is None:
+            from packaging.version import Version
+            candidates = [v for v in available if Version(v) < Version(current_version)]
+            target = max(candidates, key=lambda v: Version(v)) if candidates else None
+            if target is None:
+                click.echo(
+                    utils.Color.red(f"❌ No previous version available for {current_version}."),
+                    err=True
+                )
+                raise click.Abort()
+
+        # Display options
+        click.echo(f"Current version:  {utils.Color.bold(current_version)}")
+        click.echo(f"\nAvailable rollback versions:")
+        for v in available:
+            marker = f"  {utils.Color.bold('← default')}" if v == target else ""
+            click.echo(f"  • {utils.Color.bold(v)}{marker}")
+
+        click.echo(f"\nWill rollback: {current_version} → {utils.Color.bold(target)}")
+        click.echo(f"⚠️  This will REPLACE the current database with snapshot ho-prod-{target}.")
+
+        if not yes:
+            if not click.confirm("\nProceed?", default=False):
+                click.echo("Cancelled.")
+                return
+
+        click.echo("\nRolling back...")
+        result = mgr.rollback_production(to_version=target)
+
+        click.echo(
+            f"\n✓ {utils.Color.green('Rollback complete:')} "
+            f"{result['from_version']} → {utils.Color.bold(result['to_version'])}"
+        )
+        click.echo(f"  Branch:   {result['branch']}")
+        click.echo(f"  Snapshot: {result['snapshot']}")
+        click.echo(
+            f"\n💡 The snapshot {result['snapshot']} is still available.\n"
+            f"   To re-upgrade: half_orm dev upgrade"
+        )
+
+    except ReleaseManagerError as e:
+        click.echo(utils.Color.red(f"\n❌ {e}"), err=True)
+        raise click.Abort()
+    except Exception as e:
+        click.echo(utils.Color.red(f"\n❌ Unexpected error: {e}"), err=True)
+        raise click.Abort()

{half_orm_dev-1.0.0a29 → half_orm_dev-1.0.0a31}/half_orm_dev/cli/main.py

@@ -49,7 +49,7 @@ class Hop:
 
         # PRODUCTION ENVIRONMENT — read-only, no migrations, no dev commands
         if self.__repo.database.production:
-            return ['update', 'upgrade', 'bootstrap']
+            return ['upgrade', 'rollback']
 
         if self.__repo.needs_migration():
             return ['migrate']
@@ -61,7 +61,7 @@ class Hop:
 
         # DEVELOPMENT ENVIRONMENT - Patch development
         return ['patch', 'release', 'check', 'bootstrap', 'set-git-origin',
-                'revert-migration']
+                'revert-migration', 'recover']
 
     @property
     def repo_checked(self):

{half_orm_dev-1.0.0a29 → half_orm_dev-1.0.0a31}/half_orm_dev/database.py

@@ -1335,6 +1335,29 @@ class Database:
             'dropdb', '--if-exists', snapshot_name
         )
 
+    def restore_from_snapshot(self, snapshot_name: str) -> None:
+        """Restore this database from a snapshot (drop + recreate from template).
+
+        Requires CREATEDB privilege. Call terminate_active_connections() first,
+        then reconnect() afterwards.
+
+        Args:
+            snapshot_name: Name of the snapshot database to restore from.
+        """
+        params = self._get_connection_params()
+        self._execute_pg_command('postgres', params, 'dropdb', self.__name)
+        self._execute_pg_command('postgres', params, 'createdb', '-T', snapshot_name, self.__name)
+
+    def list_snapshots(self) -> list:
+        """Return snapshot names matching {db}_hop_snap_* pattern, sorted ascending."""
+        params = self._get_connection_params()
+        result = self._execute_pg_command(
+            'postgres', params,
+            'psql', '-d', 'postgres', '-t', '-c',
+            f"SELECT datname FROM pg_database WHERE datname LIKE '{self.__name}_hop_snap_%' ORDER BY datname"
+        )
+        return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+
     def get_postgres_version(self) -> tuple:
         """
         Get PostgreSQL server version.

{half_orm_dev-1.0.0a29 → half_orm_dev-1.0.0a31}/half_orm_dev/decorators.py

@@ -4,11 +4,23 @@ Decorators for half-orm-dev.
 Provides common decorators for ReleaseManager and PatchManager.
 """
 
+import os
 import signal
 import sys
 import inspect
 from functools import wraps
 
+from git.exc import GitCommandError
+
+
+def _has_recovery_refs(repo) -> bool:
+    """Return True if refs/hop/sync/before/* exist (Phase 2 incomplete for some branch)."""
+    try:
+        refs = repo.hgit._HGit__git_repo.git.for_each_ref('refs/hop/sync/before/')
+        return bool(refs.strip())
+    except GitCommandError:
+        return False
+
 
 def with_dynamic_branch_lock(branch_getter, timeout_minutes: int = 30):
     """
@@ -43,13 +55,12 @@ def with_dynamic_branch_lock(branch_getter, timeout_minutes: int = 30):
             repo = getattr(self, '_repo', self)
             lock_tag = None
             locked_branch = None
+            # Set to True when Phase 2 pushed some but not all branches.
+            # In that case the lock and lock file must survive so 'hop recover'
+            # can complete the work.
+            _keep_lock_for_recovery = False
             try:
                 # CRITICAL: Sync ho-prod with origin and validate version BEFORE acquiring any lock
-                # This ensures:
-                # 1. ho-prod is up-to-date (pull)
-                # 2. All branches are fetched (prune)
-                # 3. Repository hop_version is validated against installed version
-                # 4. Operation is blocked if version is outdated (prevents dangerous operations)
                 repo.sync_and_validate_ho_prod()
 
                 # Determine branch name dynamically
@@ -58,6 +69,14 @@ def with_dynamic_branch_lock(branch_getter, timeout_minutes: int = 30):
                 # Acquire lock
                 lock_tag = repo.hgit.acquire_branch_lock(locked_branch, timeout_minutes=timeout_minutes)
 
+                # Write lock file so 'hop recover' can identify ownership after a crash
+                _sync_lock_path = os.path.join(repo.base_dir, '.git', 'hop-sync-lock')
+                try:
+                    with open(_sync_lock_path, 'w') as _f:
+                        _f.write(lock_tag)
+                except OSError:
+                    pass
+
                 # Execute the method
                 result = func(self, *args, **kwargs)
 
@@ -66,20 +85,27 @@ def with_dynamic_branch_lock(branch_getter, timeout_minutes: int = 30):
                     sync_result = repo.sync_hop_to_active_branches(
                         reason=f"{func.__name__}"
                     )
-                    # Log sync errors but don't fail the operation
                     if sync_result.get('errors'):
                         for error in sync_result['errors']:
                             print(f"Warning: .hop/ sync error: {error}", file=sys.stderr)
+                        # Recovery refs remaining means Phase 2 is incomplete
+                        _keep_lock_for_recovery = _has_recovery_refs(repo)
                 except Exception as e:
-                    # Don't fail the decorated method if sync fails
                     print(f"Warning: Failed to sync .hop/ to active branches: {e}", file=sys.stderr)
+                    _keep_lock_for_recovery = _has_recovery_refs(repo)
+
+                if _keep_lock_for_recovery:
+                    print(
+                        "Warning: Sync partially failed. "
+                        "Run 'hop recover' to complete the operation.",
+                        file=sys.stderr
+                    )
 
                 return result
             finally:
-                # Always release lock (even on error)
-                # Block SIGINT during cleanup to prevent Ctrl+C from
-                # interrupting lock release and leaving an orphan tag.
-                if lock_tag:
+                if lock_tag and not _keep_lock_for_recovery:
+                    # Normal completion or pre-sync failure: release lock and clean up.
+                    # Block SIGINT to prevent Ctrl+C from leaving an orphan lock tag.
                     interrupted = False
                     original_handler = signal.getsignal(signal.SIGINT)
                     signal.signal(signal.SIGINT, lambda s, f: setattr(
@@ -93,6 +119,12 @@ def with_dynamic_branch_lock(branch_getter, timeout_minutes: int = 30):
                     if interrupted:
                         raise KeyboardInterrupt()
 
+                    _sync_lock_path = os.path.join(repo.base_dir, '.git', 'hop-sync-lock')
+                    try:
+                        os.unlink(_sync_lock_path)
+                    except FileNotFoundError:
+                        pass
+
         return wrapper
     return decorator
 

{half_orm_dev-1.0.0a29 → half_orm_dev-1.0.0a31}/half_orm_dev/file_executor.py

@@ -5,6 +5,8 @@ This module provides common file execution functionality used by both
 PatchManager and BootstrapManager.
 """
 
+import ast
+import importlib.util
 import re
 import subprocess
 import sys
@@ -98,6 +100,72 @@ def execute_python_file(file_path: Path, cwd: Optional[Path] = None) -> str:
         raise FileExecutionError(f"Failed to execute Python file {file_path.name}: {e}") from e
 
 
+def _has_run_entrypoint(file_path: Path) -> bool:
+    """Return True if the file defines a top-level run() function."""
+    try:
+        tree = ast.parse(file_path.read_text(encoding='utf-8'))
+    except (OSError, SyntaxError):
+        return False
+    return any(
+        isinstance(node, ast.FunctionDef) and node.name == 'run'
+        for node in tree.body
+    )
+
+
+def execute_python_bootstrap(file_path: Path, model, cwd: Optional[Path] = None) -> str:
+    """
+    Execute a Python bootstrap script.
+
+    Fast path — if the script defines a top-level run(model) function it is
+    loaded in-process via importlib and called with the live database model,
+    sharing the existing connection.
+
+    Slow path — scripts without run(model) are executed as a subprocess
+    (backwards-compatible with pre-API scripts).
+
+    Args:
+        file_path: Path to Python bootstrap script
+        model: halfORM Model instance (shared database connection)
+        cwd: Working directory for execution (default: file's parent)
+
+    Returns:
+        Return value of run() converted to str, or subprocess stdout.
+        Empty string if run() returns None.
+
+    Raises:
+        FileExecutionError: If execution fails
+    """
+    if cwd is None:
+        cwd = file_path.parent
+
+    if not _has_run_entrypoint(file_path):
+        return execute_python_file(file_path, cwd)
+
+    module_name = f"_hop_bootstrap_{file_path.stem.replace('-', '_').replace('.', '_')}"
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    module = importlib.util.module_from_spec(spec)
+
+    cwd_str = str(cwd)
+    inserted = cwd_str not in sys.path
+    if inserted:
+        sys.path.insert(0, cwd_str)
+
+    try:
+        spec.loader.exec_module(module)
+        result = module.run(model)
+        return str(result) if result is not None else ''
+    except FileExecutionError:
+        raise
+    except Exception as e:
+        raise FileExecutionError(
+            f"Python execution failed in {file_path.name}: {e}"
+        ) from e
+    finally:
+        if inserted and cwd_str in sys.path:
+            sys.path.remove(cwd_str)
+        sys.modules.pop(module_name, None)
+
+
 _HOP_MARKER = re.compile(r"(--|#)\s*@hop:(bootstrap|data)")