half-orm-dev 1.0.0a28__tar.gz → 1.0.0a30__tar.gz

{half_orm_dev-1.0.0a28/half_orm_dev.egg-info → half_orm_dev-1.0.0a30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 1.0.0a28
+Version: 1.0.0a30
 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.0a28 → half_orm_dev-1.0.0a30}/half_orm_dev/bootstrap_manager.py

@@ -141,12 +141,9 @@ class BootstrapManager:
         """
         # If schema or table isn't ready yet (pre-migration state),
         # return empty set so all bootstrap files are treated as pending.
-        try:
-            self._ensure_bootstrap_table()
-            HopBootstrap = self._repo.database.model.get_relation_class('half_orm_meta.bootstrap')
-            return {row.filename for row in HopBootstrap()}
-        except Exception:
-            return set()
+        self._ensure_bootstrap_table()
+        HopBootstrap = self._repo.database.model.get_relation_class('half_orm_meta.bootstrap')
+        return {row['filename'] for row in HopBootstrap()}
 
     def get_pending_files(
         self,
@@ -167,7 +164,6 @@ class BootstrapManager:
         """
         all_files = self.get_bootstrap_files(up_to_version, exclude_version=exclude_version, for_version=for_version)
         executed = self.get_executed_files()
-
         return [f for f in all_files if f.name not in executed]
 
     def execute_file(self, file_path: Path) -> None:
@@ -270,7 +266,7 @@ class BootstrapManager:
                 result['executed'].append(filename)
                 continue
 
-            if filename in executed_set:
+            if not force and filename in executed_set:
                 result['skipped'].append(filename)
                 continue
 

{half_orm_dev-1.0.0a28 → half_orm_dev-1.0.0a30}/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.0a30/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.0a30/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.0a28 → half_orm_dev-1.0.0a30}/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.0a28 → half_orm_dev-1.0.0a30}/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.0a28 → half_orm_dev-1.0.0a30}/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