create webapp and copy wsgi file

Author: copelco

dsd_pythonanywhere/client.py

@@ -4,10 +4,12 @@
 import time
 import webbrowser
 from dataclasses import dataclass
+from pathlib import Path
 
 import requests
 from django_simple_deploy.management.commands.utils import plugin_utils
 from pythonanywhere_core.base import get_api_endpoint
+from pythonanywhere_core.webapp import Webapp
 from requests.adapters import HTTPAdapter
 
 logger = logging.getLogger(__name__)
@@ -123,7 +125,7 @@ class Console:
     See https://help.pythonanywhere.com/pages/API/#consoles for more details.
     """
 
-    def __init__(self, bash_console: dict, api_client: "APIClient"):
+    def __init__(self, bash_console: dict, api_client: "PythonAnywhereClient"):
         # Full console info returned from Consoles API endpoint
         self.bash_console = bash_console
         self.api_client = api_client
@@ -255,8 +257,8 @@ def run_command(self, command: str) -> str:
         return result.output
 
 
-class APIClient:
-    """PythonAnywhere API client."""
+class PythonAnywhereClient:
+    """Client for interacting with the PythonAnywhere API, including console and webapp management."""
 
     def __init__(self, username: str):
         self.username = username
@@ -265,19 +267,19 @@ def __init__(self, username: str):
         self.session.headers.update({"Authorization": f"Token {self.token}"})
         self.session.mount("https://", HTTPAdapter(max_retries=3))
 
-    @property
-    def _hostname(self) -> str:
-        """Get the PythonAnywhere hostname.
+        # Initialize webapp for this user's domain
+        self.domain_name = f"{username}.{self._pythonanywhere_domain}"
+        self.webapp = Webapp(self.domain_name)
 
-        This uses the same method as pythonanywhere_core to determine the hostname.
+    @property
+    def _pythonanywhere_domain(self) -> str:
+        """Get the PythonAnywhere domain (e.g., 'pythonanywhere.com')."""
+        return os.getenv("PYTHONANYWHERE_DOMAIN", "pythonanywhere.com")
 
-        Returns:
-            The hostname (e.g., "www.pythonanywhere.com")
-        """
-        return os.getenv(
-            "PYTHONANYWHERE_SITE",
-            "www." + os.getenv("PYTHONANYWHERE_DOMAIN", "pythonanywhere.com"),
-        )
+    @property
+    def _hostname(self) -> str:
+        """Get the PythonAnywhere API hostname (e.g., 'www.pythonanywhere.com')."""
+        return os.getenv("PYTHONANYWHERE_SITE", f"www.{self._pythonanywhere_domain}")
 
     def _base_url(self, flavor: str) -> str:
         """Construct the base URL for a specific API endpoint flavor.
@@ -323,6 +325,8 @@ def request(self, method: str, url: str, **kwargs):
         log_message(f"API response: {response.status_code} {response.text}")
         return response
 
+    # --- Console management methods ---
+
     def get_active_console(self) -> Console:
         """Return an active PythonAnywhere bash console."""
         base_url = self._base_url("consoles")
@@ -354,3 +358,79 @@ def run_command(self, command: str) -> str:
             raise RuntimeError("No active bash console found")
 
         return console.run_command(command)
+
+    # --- Webapp management methods ---
+
+    def webapp_exists(self) -> bool:
+        """Check if a web app already exists for this domain.
+
+        Returns:
+            True if a webapp exists, False otherwise
+        """
+        webapps = self.webapp.list_webapps()
+        return any(app.get("domain_name") == self.domain_name for app in webapps)
+
+    def create_webapp(
+        self,
+        python_version: str,
+        virtualenv_path: str | Path,
+        project_path: str | Path,
+        nuke: bool = False,
+    ) -> dict:
+        """Create a new web app on PythonAnywhere.
+
+        Args:
+            python_version: Python version (e.g., "3.13")
+            virtualenv_path: Path to the virtual environment
+            project_path: Path to the Django project
+            nuke: If True, delete existing webapp before creating
+
+        Returns:
+            The webapp configuration dict
+        """
+        log_message(f"Creating webapp for {self.domain_name}...")
+        self.webapp.sanity_checks(nuke=nuke)
+        result = self.webapp.create(
+            python_version=python_version,
+            virtualenv_path=str(virtualenv_path),
+            project_path=str(project_path),
+            nuke=nuke,
+        )
+        log_message(f"Webapp created: {self.domain_name}")
+        return result
+
+    def reload_webapp(self) -> None:
+        """Reload the web app to apply changes."""
+        log_message(f"Reloading webapp {self.domain_name}...")
+        self.webapp.reload()
+        log_message("Webapp reloaded successfully")
+
+    def create_or_update_webapp(
+        self,
+        python_version: str,
+        virtualenv_path: str | Path,
+        project_path: str | Path,
+    ) -> None:
+        """Create or update a webapp.
+
+        This is a convenience method that:
+        1. Creates the webapp if it doesn't exist
+        2. Reloads the webapp
+
+        Args:
+            python_version: Python version (e.g., "3.13")
+            virtualenv_path: Path to the virtual environment
+            project_path: Path to the Django project
+        """
+        if not self.webapp_exists():
+            self.create_webapp(
+                python_version=python_version,
+                virtualenv_path=virtualenv_path,
+                project_path=project_path,
+                nuke=False,
+            )
+        else:
+            log_message(f"Webapp {self.domain_name} already exists, skipping creation")
+
+        # Always reload to apply changes
+        self.reload_webapp()

dsd_pythonanywhere/platform_deployer.py

@@ -49,7 +49,7 @@ def _add_requirements(self):
 from django_simple_deploy.management.commands.utils import plugin_utils
 from django_simple_deploy.management.commands.utils.plugin_utils import dsd_config
 
-from dsd_pythonanywhere.client import APIClient
+from dsd_pythonanywhere.client import PythonAnywhereClient
 
 from . import deploy_messages as platform_msgs
 
@@ -73,6 +73,8 @@ class PlatformDeployer:
 
     def __init__(self):
         self.templates_path = Path(__file__).parent / "templates"
+        self.api_user = os.getenv("API_USER")
+        self.client = PythonAnywhereClient(username=self.api_user)
 
     # --- Public methods ---
 
@@ -105,7 +107,7 @@ def _validate_platform(self):
         pass
 
     def _get_origin_url(self) -> str:
-        """"""
+        """Get the git remote origin URL."""
         origin_url = (
             plugin_utils.run_quick_command("git config --get remote.origin.url", check=True)
             .stdout.decode()
@@ -123,7 +125,7 @@ def _get_origin_url(self) -> str:
         return https_url
 
     def _get_deployed_project_name(self):
-        return os.getenv("API_USER")
+        return self.api_user
 
     def _get_repo_name(self) -> str:
         """Get the repository name from the git remote URL.
@@ -142,16 +144,34 @@ def _prep_automate_all(self):
         pass
 
     def _clone_and_run_setup_script(self):
-        client = APIClient(username=os.getenv("API_USER"))
-        # Proof of concept to run script remotely on Python Anywhere
+        # Run the setup script to clone repo and install dependencies
         cmd = [f"curl -fsSL {REMOTE_SETUP_SCRIPT_URL} | bash -s --"]
         origin_url = self._get_origin_url()
         repo_name = self._get_repo_name()
-        cmd.append(f"{origin_url} {repo_name}")
+        django_project_name = dsd_config.local_project_name
+        cmd.append(f"{origin_url} {repo_name} {django_project_name}")
         cmd = " ".join(cmd)
         plugin_utils.write_output(f"  Cloning and running setup script: {cmd}")
-        client.run_command(cmd)
+        self.client.run_command(cmd)
         plugin_utils.write_output("Done cloning and running setup script.")
+        # Finally, create the webapp
+        self._create_webapp(client=self.client, repo_name=repo_name)
+
+    def _create_webapp(self, client: PythonAnywhereClient, repo_name: str):
+        """Create the webapp on PythonAnywhere."""
+        plugin_utils.write_output("  Creating webapp on PythonAnywhere...")
+
+        # Paths on PythonAnywhere (remote home directory)
+        remote_home = Path(f"/home/{client.username}")
+        project_path = remote_home / repo_name
+        virtualenv_path = remote_home / "venv"
+
+        client.create_or_update_webapp(
+            python_version="3.13",
+            virtualenv_path=virtualenv_path,
+            project_path=project_path,
+        )
+        plugin_utils.write_output("Webapp created and configured.")
 
     def _add_requirements(self):
         """Add requirements for deploying to PythonAnywhere."""
@@ -215,6 +235,7 @@ def _conclude_automate_all(self):
 
         # Should set self.deployed_url, which will be reported in the success message.
         self._clone_and_run_setup_script()
+
         self.deployed_url = f"https://{self._get_deployed_project_name()}.pythonanywhere.com"
 
     def _show_success_message(self):

scripts/setup.sh

@@ -1,19 +1,25 @@
 #!/bin/bash
 set -e
 
-if [ -z "$1" ] || [ -z "$2" ]; then
-	echo "Usage: $0 <git-repo-url> <directory-name> <python-version>"
+if [ -z "$1" ] || [ -z "$2" ] || [ -z "$3" ]; then
+	echo "Usage: $0 <git-repo-url> <directory-name> <django-project-name> [python-version] [wsgi-dest-prefix]"
 	exit 1
 fi
 
+GIT_REPO_URL=$1
+REPO_NAME=$2
+DJANGO_PROJECT_NAME=$3
+PYTHON_VERSION=${4:-python3.13}
+WSGI_DEST_PREFIX=${5:-/var/www}
+
 # Clone the repository from the provided Git URL
 
 echo "Cloning repository..."
 
-if [ ! -d "$2" ]; then
-	git clone "$1" "$2"
+if [ ! -d "$REPO_NAME" ]; then
+	git clone "$GIT_REPO_URL" "$REPO_NAME"
 else
-	echo "Directory $2 already exists. Skipping clone."
+	echo "Directory $REPO_NAME already exists. Skipping clone."
 fi
 
 # Create and activate a Python virtual environment, if it doesn't already exist
@@ -22,7 +28,7 @@ echo "Setting up Python virtual environment..."
 
 if [ ! -d "venv" ]; then
 	echo "Creating virtual environment..."
-	${3:-python3.13} -m venv venv
+	$PYTHON_VERSION -m venv venv
 fi
 
 echo "Activating virtual environment..."
@@ -31,16 +37,16 @@ source venv/bin/activate
 echo "Installing dependencies..."
 
 ./venv/bin/pip install --upgrade pip
-./venv/bin/pip install -r $2/requirements.txt
+./venv/bin/pip install -r $REPO_NAME/requirements.txt
 
 # Create .env file with environment variables
 
 echo "Creating .env file..."
 
-if [ ! -f "$2/.env" ]; then
+if [ ! -f "$REPO_NAME/.env" ]; then
 	# Generate a random Django secret key
 	DJANGO_SECRET_KEY=$(./venv/bin/python -c "from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())")
-	cat > "$2/.env" << EOF
+	cat > "$REPO_NAME/.env" << EOF
 DEBUG=TRUE
 ON_PYTHONANYWHERE=TRUE
 SECRET_KEY=$DJANGO_SECRET_KEY
@@ -50,4 +56,15 @@ else
 	echo ".env file already exists. Skipping creation."
 fi
 
+# Copy wsgi.py to PythonAnywhere's wsgi location
+USERNAME=$(whoami)
+DOMAIN="${USERNAME}.pythonanywhere.com"
+WSGI_DEST="${WSGI_DEST_PREFIX}/${DOMAIN//./_}_wsgi.py"
+WSGI_SRC="$REPO_NAME/$DJANGO_PROJECT_NAME/wsgi.py"
+
+echo "Copying WSGI file from $WSGI_SRC to $WSGI_DEST..."
+mkdir -p "$WSGI_DEST_PREFIX"
+cp "$WSGI_SRC" "$WSGI_DEST"
+echo "WSGI file copied."
+
 echo "Setup complete!!!"

tests/integration_tests/test_setup_script.py

@@ -1,5 +1,6 @@
 """Integration tests for the PythonAnywhere setup.sh script."""
 
+import getpass
 import subprocess
 import sys
 from pathlib import Path
@@ -15,13 +16,24 @@ def setup_script_result(tmp_path_factory) -> dict:
     tmp_path = tmp_path_factory.mktemp("setup_script")
     script_path = Path(__file__).parent.parent.parent / "scripts" / "setup.sh"
     dir_name = "test_project"
+    django_project_name = "mysite"
     # Use the current Python version available on CI for testing
     python_version = f"python{sys.version_info.major}.{sys.version_info.minor}"
+    # Use a temp directory for WSGI destination prefix
+    wsgi_dest_prefix = tmp_path / "var_www"
 
-    # Create a minimal git repository with a requirements.txt file
+    # Create a minimal git repository with a requirements.txt file and Django project
     source_repo = tmp_path / "source_repo"
     source_repo.mkdir()
     (source_repo / "requirements.txt").write_text("django\n")
+
+    # Create a minimal Django project structure with wsgi.py
+    django_project_dir = source_repo / django_project_name
+    django_project_dir.mkdir()
+    (django_project_dir / "wsgi.py").write_text(
+        'import os\nos.environ.setdefault("DJANGO_SETTINGS_MODULE", "mysite.settings")\n'
+    )
+
     subprocess.run(["git", "init"], cwd=source_repo, check=True, capture_output=True)
     subprocess.run(["git", "add", "."], cwd=source_repo, check=True, capture_output=True)
     subprocess.run(
@@ -34,7 +46,15 @@ def setup_script_result(tmp_path_factory) -> dict:
     repo_url = source_repo.as_uri()
 
     result = subprocess.run(
-        ["bash", str(script_path), repo_url, dir_name, python_version],
+        [
+            "bash",
+            str(script_path),
+            repo_url,
+            dir_name,
+            django_project_name,
+            python_version,
+            str(wsgi_dest_prefix),
+        ],
         cwd=tmp_path,
         check=True,
         capture_output=True,
@@ -46,6 +66,8 @@ def setup_script_result(tmp_path_factory) -> dict:
         "tmp_path": tmp_path,
         "venv_path": tmp_path / "venv",
         "project_path": tmp_path / dir_name,
+        "django_project_name": django_project_name,
+        "wsgi_dest_prefix": wsgi_dest_prefix,
     }
 
 
@@ -82,3 +104,15 @@ def test_setup_script_creates_env_file(setup_script_result):
         if line.startswith("SECRET_KEY="):
             secret_key = line.split("=", 1)[1]
             assert len(secret_key) == 50
+
+
+def test_setup_script_copies_wsgi_file(setup_script_result):
+    """setup.sh copies WSGI file to the destination prefix."""
+    username = getpass.getuser()
+    domain = f"{username}.pythonanywhere.com"
+    wsgi_filename = f"{domain.replace('.', '_')}_wsgi.py"
+    wsgi_dest = setup_script_result["wsgi_dest_prefix"] / wsgi_filename
+
+    assert "WSGI file copied." in setup_script_result["result"].stdout
+    assert wsgi_dest.exists()
+    assert "DJANGO_SETTINGS_MODULE" in wsgi_dest.read_text()