djaploy 0.9.1__tar.gz → 0.9.3__tar.gz

{djaploy-0.9.1 → djaploy-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djaploy
-Version: 0.9.1
+Version: 0.9.3
 Summary: Modular Django deployment system based on pyinfra
 Author-email: Johanna Mae Dimayuga <johanna@techco.fi>
 License: MIT License

{djaploy-0.9.1 → djaploy-0.9.3}/djaploy/config.py

@@ -71,7 +71,7 @@ class DjaployConfig:
     artifact_dir: str = "deployment"
     deployment_strategy: str = "in_place"  # "in_place" or "zero_downtime"
     keep_releases: int = 5  # Number of releases to keep (zero_downtime only)
-    # Paths (relative to app root) to symlink from shared/ into each release.
+    # Paths (relative to git/artifact root) to symlink from shared/ into each release.
     # When None (default), auto-detected from Django settings (STATIC_ROOT,
     # MEDIA_ROOT, PRIVATE_MEDIA_ROOT). Set explicitly to override or to [] to disable.
     # Note: venv is shared implicitly via the stable current/ symlink path.
@@ -118,8 +118,8 @@ class DjaployConfig:
         """Auto-detect shared resources from Django settings.
 
         Resolves STATIC_ROOT, MEDIA_ROOT and PRIVATE_MEDIA_ROOT relative to
-        project_dir. Only includes paths that are inside the project directory
-        (paths outside the app dir don't need symlinking).
+        git_dir (the artifact/release root). Only includes paths that are
+        inside the project directory (paths outside don't need symlinking).
         """
         resources = []
         try:
@@ -127,17 +127,22 @@ class DjaployConfig:
             if not django_settings.configured:
                 return resources
 
-            base_dir = Path(django_settings.BASE_DIR)
+            # Resolve relative to git_dir (artifact root) so paths match
+            # the release directory structure, not BASE_DIR which may be
+            # a subdirectory of the artifact.
+            artifact_root = self.git_dir or self.project_dir
+            if artifact_root is None:
+                return resources
 
             for setting_name in ('STATIC_ROOT', 'MEDIA_ROOT', 'PRIVATE_MEDIA_ROOT'):
                 value = getattr(django_settings, setting_name, None)
                 if value:
                     abs_path = Path(value)
                     try:
-                        rel = str(abs_path.relative_to(base_dir))
+                        rel = str(abs_path.relative_to(artifact_root))
                         resources.append(rel)
                     except ValueError:
-                        pass  # Outside BASE_DIR, no symlink needed
+                        pass  # Outside artifact root, no symlink needed
         except Exception:
             pass
         return resources

{djaploy-0.9.1 → djaploy-0.9.3}/djaploy/modules/core.py

@@ -136,15 +136,19 @@ class CoreModule(BaseModule):
                 _sudo=True,
             )
 
-        # Create shared resource directories
+        # Create shared resource directories (mkdir -p for nested paths)
         shared_resources = getattr(project_config, 'shared_resources', [])
-        for resource in shared_resources:
-            if not resource.startswith('.'):
-                files.directory(
-                    name=f"Create shared/{resource} directory",
-                    path=f"{app_path}/shared/{resource}",
-                    user=app_user,
-                    group=app_user,
+        if shared_resources:
+            mkdir_commands = [
+                f"mkdir -p {app_path}/shared/{resource}"
+                for resource in shared_resources
+                if not resource.startswith('.')
+            ]
+            if mkdir_commands:
+                mkdir_commands.append(f"chown -R {app_user}:{app_user} {app_path}/shared")
+                server.shell(
+                    name="Create shared resource directories",
+                    commands=mkdir_commands,
                     _sudo=True,
                 )
 
@@ -259,13 +263,35 @@ class CoreModule(BaseModule):
     def post_deploy(self, host_data: Dict[str, Any], project_config: Dict[str, Any], artifact_path: Path):
         """Run migrations and collectstatic after all modules have deployed their files"""
         app_user = getattr(host_data, 'app_user', None) or project_config.app_user
+
         if self._is_zero_downtime(project_config):
-            app_path = f"{self._get_app_path(host_data, project_config)}/current"
+            # Run migrations and collectstatic via the stable build/ symlink
+            # so Poetry resolves the same virtualenv used during install.
+            # Old workers keep serving from current/ without interruption.
+            base_path = self._get_app_path(host_data, project_config)
+            build_path = f"{base_path}/build"
+            release_path = getattr(host.data, '_zero_downtime_release_path', None)
+            app_path = build_path if release_path else f"{base_path}/current"
+
+            self._run_migrations(app_user, app_path, project_config)
+            self._collect_static(app_user, app_path, project_config)
+
+            # Atomic symlink swap AFTER everything is ready.
+            # Old workers continue serving until USR2 triggers the handoff.
+            if release_path:
+                server.shell(
+                    name="Swap current symlink to new release",
+                    commands=[
+                        f"ln -sfn {release_path} {base_path}/current.tmp && mv -Tf {base_path}/current.tmp {base_path}/current",
+                    ],
+                    _sudo=True,
+                    _sudo_user=app_user,
+                    _use_sudo_login=True,
+                )
         else:
             app_path = self._get_app_path(host_data, project_config)
-
-        self._run_migrations(app_user, app_path, project_config)
-        self._collect_static(app_user, app_path, project_config)
+            self._run_migrations(app_user, app_path, project_config)
+            self._collect_static(app_user, app_path, project_config)
 
     def rollback(self, host_data: Dict[str, Any], project_config: Dict[str, Any], release: str = None):
         """Roll back to a previous release by swapping the current symlink"""
@@ -433,27 +459,24 @@ class CoreModule(BaseModule):
         if getattr(host_data, 'pregenerate_certificates', False):
             self._generate_ssl_certificates(host_data, app_user)
 
-        # Atomic symlink swap BEFORE installing deps so Poetry sees a stable
-        # path (current/) and reuses the same virtualenv across releases.
-        # Use mv -Tf for a truly atomic swap (ln -sfn unlinks then creates,
-        # leaving a brief window where current doesn't exist).
+        # Install deps via a stable build/ symlink so Poetry reuses the same
+        # virtualenv across releases (Poetry keys venvs by directory path).
+        # The symlink swap to current/ is deferred to post_deploy so old
+        # workers keep serving from the previous release without interruption.
+        build_link = f"{app_path}/build"
         server.shell(
-            name=f"Swap current symlink to {release_name}",
+            name="Create stable build symlink for Poetry",
             commands=[
-                f"ln -sfn {release_path} {app_path}/current.tmp && mv -Tf {app_path}/current.tmp {app_path}/current",
+                f"ln -sfn {release_path} {build_link}",
             ],
             _sudo=True,
             _sudo_user=app_user,
             _use_sudo_login=True,
         )
+        self._install_dependencies(app_user, build_link, project_config)
 
-        # Install deps via the stable current/ path.
-        # Poetry keys virtualenvs by directory — using current/ means it
-        # reuses the same venv across deploys (shared venv behavior).
-        # Migrations and collectstatic are deferred to post_deploy so that
-        # other modules (e.g. local_settings) can place config files first.
-        current_path = f"{app_path}/current"
-        self._install_dependencies(app_user, current_path, project_config)
+        # Store release path so other modules and post_deploy can access it
+        host.data._zero_downtime_release_path = release_path
 
         # Clean up old releases
         keep_releases = getattr(project_config, 'keep_releases', 5)
@@ -531,11 +554,13 @@ class CoreModule(BaseModule):
 
         python_version = project_config.python_version
 
+        poetry_bin = f"/home/{app_user}/.local/bin/poetry"
+
         commands = [
-            # First configure Poetry to not use in-project virtualenvs on the server
-            f"/home/{app_user}/.local/bin/poetry config virtualenvs.in-project false",
+            # Configure Poetry to not use in-project virtualenvs on the server
+            f"{poetry_bin} config virtualenvs.in-project false",
             # Ensure the virtualenv uses the configured Python version
-            f"/home/{app_user}/.local/bin/poetry env use python{python_version}",
+            f"{poetry_bin} env use python{python_version}",
         ]
 
         # Optionally regenerate the lock file before installation

{djaploy-0.9.1 → djaploy-0.9.3}/djaploy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djaploy
-Version: 0.9.1
+Version: 0.9.3
 Summary: Modular Django deployment system based on pyinfra
 Author-email: Johanna Mae Dimayuga <johanna@techco.fi>
 License: MIT License

{djaploy-0.9.1 → djaploy-0.9.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "djaploy"
-version = "0.9.1"
+version = "0.9.3"
 description = "Modular Django deployment system based on pyinfra"
 authors = [
     {name = "Johanna Mae Dimayuga", email = "johanna@techco.fi"}