Refactor action: migrate deployment logic from Bash script to Python (#3)

MiguelRizzi · web-flow · commit a60da5704eb1 · 2025-06-24T23:24:51.000-03:00
* Migrate deployment logic from Bash script to Python

* Update README.md
diff --git a/.dockerignore b/.dockerignore
@@ -0,0 +1,17 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+*.egg
+*.log
+*.tmp
+*.swp
+venv/
+.env
+.git
+.gitignore
+.DS_Store
+node_modules/
+tests/
+test/
+README.md
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,7 @@
+__pycache__
+*.pyc
+*.egg-info
+venv
+.env
+*.log
+*.tmp
diff --git a/Dockerfile b/Dockerfile
@@ -1,9 +1,12 @@
-FROM ubuntu:22.04
+FROM python:3.11-slim
 
-RUN apt-get update && \
-    apt-get install -y openssh-client sshpass git python3 python3-pip
+WORKDIR /app
+ENV PYTHONPATH="/app"
 
-COPY deploy.sh /deploy.sh
-RUN chmod +x /deploy.sh
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY deploy/ ./deploy/
+
+CMD ["python", "-m", "deploy.main"]
 
-ENTRYPOINT ["/deploy.sh"]
diff --git a/README.md b/README.md
@@ -19,6 +19,7 @@ Before using this action, make sure that:
 - Pulls the latest code from the `main` branch  
 - Installs Python dependencies with `pip`  
 - Runs `collectstatic` and `migrate`  
+- Runs tests
 - Restarts the web server by touching the `WSGI` file
 
 
@@ -65,7 +66,7 @@ jobs:
           # Required: path to your WSGI file
           wsgi_file: /var/www/webapp_name_wsgi.py
 ```
--💡 Use `ssh.pythonanywhere.com` for US accounts or `ssh.eu.pythonanywhere.com` for EU-based accounts.  
+> 💡 Use `ssh.pythonanywhere.com` for US accounts or `ssh.eu.pythonanywhere.com` for EU-based accounts.  
 🔐 You must provide **at least one** of the following:  `password` or `ssh_private_key`
 
 
diff --git a/action.yml b/action.yml
@@ -1,5 +1,5 @@
 name: PythonAnywhere Redeploy Action
-description: Redeploy a Django app to PythonAnywhere via SSH using Docker.
+description: Redeploy a Django app to PythonAnywhere via SSH.
 author: MiguelRizzi
 
 branding:
@@ -33,11 +33,11 @@ inputs:
 runs:
   using: docker
   image: Dockerfile
-  args:
-    - ${{ inputs.ssh_host }}
-    - ${{ inputs.username }}
-    - ${{ inputs.password }}
-    - ${{ inputs.ssh_private_key }}
-    - ${{ inputs.working_directory }}
-    - ${{ inputs.venv_directory }}
-    - ${{ inputs.wsgi_file }}
+  env:
+    SSH_HOST: ${{ inputs.ssh_host }}
+    USERNAME: ${{ inputs.username }}
+    PASSWORD: ${{ inputs.password }}
+    SSH_PRIVATE_KEY: ${{ inputs.ssh_private_key }}
+    WORKING_DIRECTORY: ${{ inputs.working_directory }}
+    VENV_DIRECTORY: ${{ inputs.venv_directory }}
+    WSGI_FILE: ${{ inputs.wsgi_file }}
diff --git a/deploy.sh b/deploy.sh
diff --git a/deploy/__init__ .py b/deploy/__init__ .py
diff --git a/deploy/deploy_manager.py b/deploy/deploy_manager.py
@@ -0,0 +1,73 @@
+from .logger import logger
+
+class DeployManager:
+    def __init__(self, ssh, workdir, venvdir, wsgi):
+        self.ssh = ssh
+        self.workdir = workdir
+        self.venv = f"source {venvdir}/bin/activate"
+        self.wsgi = wsgi
+        self.prev_commit = ""
+
+    def post_pull_tasks(self, changes):
+        def changed(path): return any(path in f for f in changes)
+
+        if changed("requirements.txt"):
+            logger.info("requirements.txt changed. Installing dependencies...")
+            self.ssh.exec(f"cd {self.workdir} && {self.venv} && pip install -r requirements.txt")
+        
+        if any("models.py" in f or f.startswith("migrations/") for f in changes):
+            logger.info("Model or migration changes detected. Running migrations...")
+            self.ssh.exec(f"cd {self.workdir} && {self.venv} && python manage.py makemigrations")
+            self.ssh.exec(f"cd {self.workdir} && {self.venv} && python manage.py migrate")
+
+        if any("static" in f for f in changes):
+            logger.info("Static files changed. Running collectstatic...")
+            self.ssh.exec(f"cd {self.workdir} && {self.venv} && python manage.py collectstatic --noinput")
+        
+        logger.info("Running tests...")
+        out, err = self.ssh.exec(f"cd {self.workdir} && {self.venv} && python manage.py test")
+        if err and not "Ran 0 tests" in err:
+            logger.error("Tests failed")
+            raise Exception(err)
+        else:
+            logger.info("Tests passed successfully.")
+
+    def get_changed_files(self):
+        out, _ = self.ssh.exec(f"cd {self.workdir} && git rev-parse HEAD")
+        self.prev_commit = out.strip()
+        logger.info(f"Previous commit: {self.prev_commit}")
+
+        logger.info("Checking for changes in the remote repository...")
+        self.ssh.exec(f"cd {self.workdir} && git fetch origin")
+        out, _ = self.ssh.exec(f"cd {self.workdir} && git diff --name-only origin/main..HEAD")
+        return out.splitlines()
+
+    def rollback_to_previous_commit(self):
+        logger.warning("Rolling back to previous commit...")
+        self.ssh.exec(f"cd {self.workdir} && git reset --hard {self.prev_commit}")
+
+    def deploy(self):
+        try:
+            changes = self.get_changed_files()
+            if changes:
+                logger.info("Changed files:\n  " + "\n  ".join(changes))
+                self.ssh.exec(f"cd {self.workdir} && git pull origin main")
+                logger.info("Pulled latest changes from remote repository.")
+                try:
+                    self.post_pull_tasks(changes)
+                except Exception:
+                    logger.exception("Error during post-pull tasks")
+                    self.rollback_to_previous_commit()
+                    logger.warning("Rolled back due to test failure.")
+                    raise
+            else:
+                logger.info("No files changed.")
+
+            logger.info("Reloading application (touch WSGI)...")
+            self.ssh.exec(f"touch {self.wsgi}")
+            logger.info("Deployment completed successfully!")
+
+        except Exception:
+            logger.exception("Error during deployment")
+            self.rollback_to_previous_commit()
+            raise
diff --git a/deploy/logger.py b/deploy/logger.py
@@ -0,0 +1,9 @@
+import logging
+
+formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(funcName)s - %(message)s')
+handler = logging.StreamHandler()
+handler.setFormatter(formatter)
+
+logger = logging.getLogger(__name__)
+logger.addHandler(handler)
+logger.setLevel(logging.INFO)
diff --git a/deploy/main.py b/deploy/main.py
@@ -0,0 +1,50 @@
+import os
+
+from .logger import logger
+from .ssh_connector import SSHConnector
+from .deploy_manager import DeployManager
+
+def verify_env_variables():
+    required_vars = [
+        "SSH_HOST", "USERNAME", "WORKING_DIRECTORY", "VENV_DIRECTORY", "WSGI_FILE"
+    ]
+
+    missing = [var for var in required_vars if not os.environ.get(var)]
+    if missing:
+        msg = f"Missing environment variables: {', '.join(missing)}"
+        logger.critical(msg)
+        raise EnvironmentError(msg)
+
+    if not (os.environ.get("PASSWORD") or os.environ.get("SSH_PRIVATE_KEY")):
+        msg = "Neither PASSWORD nor SSH_PRIVATE_KEY is set"
+        logger.error(msg)
+        raise EnvironmentError(msg)
+
+
+def main():
+    verify_env_variables()
+    ssh = SSHConnector(
+        hostname=os.environ.get("SSH_HOST"),
+        port=22,
+        username=os.environ.get("USERNAME"),
+        password=os.environ.get("PASSWORD"),
+        key_filename=None,
+        private_key_str=os.environ.get("SSH_PRIVATE_KEY"),
+    )
+    try:
+        ssh.connect()
+        if ssh.client:
+            manager = DeployManager(
+                ssh,
+                workdir=os.environ.get("WORKING_DIRECTORY"),
+                venvdir=os.environ.get("VENV_DIRECTORY"),
+                wsgi=os.environ.get("WSGI_FILE")
+            )
+            manager.deploy()
+    except Exception:
+        logger.exception("Fatal error during deployment")
+    finally:
+        ssh.disconnect()
+
+if __name__ == "__main__":
+    main()
diff --git a/deploy/ssh_connector.py b/deploy/ssh_connector.py
@@ -0,0 +1,70 @@
+import paramiko
+import os
+import tempfile
+from .logger import logger
+
+class SSHConnector:
+    def __init__(self, hostname, port, username, password=None, key_filename=None, private_key_str=None):
+        self.hostname = hostname
+        self.port = port
+        self.username = username
+        self.password = password
+        self.key_filename = key_filename
+        self.private_key_str = private_key_str
+        self.client = None
+
+    def connect(self):
+        try:
+            logger.info(f"Connecting to {self.hostname} on port {self.port}...")
+            self.client = paramiko.SSHClient()
+            self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+            if self.private_key_str:
+                logger.info("Using private key for authentication.")
+                with tempfile.NamedTemporaryFile(delete=False, mode='w') as tmp_key:
+                    tmp_key.write(self.private_key_str)
+                    tmp_key_path = tmp_key.name
+                try:
+                    self.client.connect(
+                        self.hostname,
+                        port=self.port,
+                        username=self.username,
+                        key_filename=tmp_key_path
+                    )
+                finally:
+                    os.remove(tmp_key_path)
+            else:
+                logger.info("Using password authentication.")
+                self.client.connect(
+                    self.hostname,
+                    port=self.port,
+                    username=self.username,
+                    password=self.password,
+                )
+            logger.info("Connected to the SSH server successfully.")
+        except Exception:
+            logger.exception("Connection failed")
+            self.client = None
+            raise
+
+    def disconnect(self):
+        if self.client:
+            self.client.close()
+            logger.info("Disconnected from the SSH server.")
+
+    def exec(self, command):
+        if not self.client:
+            logger.error("Not connected to SSH server.")
+            raise Exception("Not connected to SSH server.")
+        logger.info(f"Executing command: {command}")
+        try:
+            stdin, stdout, stderr = self.client.exec_command(command)
+            out = stdout.read().decode()
+            err = stderr.read().decode()
+            if out:
+                logger.info(f"STDOUT: {out}")
+            if err:
+                logger.warning(f"STDERR: {err}")
+            return out, err
+        except Exception:
+            logger.exception(f"Failed to execute command: {command}")
+            raise

-Original file line number
+Diff line change
@@ @@ -0,0 +1,7 @@ @@
 +__pycache__
 +*.pyc
 +*.egg-info
 +venv
 +.env
 +*.log
 +*.tmp