pystrano 1.0.0__py3-none-any.whl

pystrano/config.py

@@ -0,0 +1,98 @@
+from dotenv import dotenv_values
+from yaml import safe_load
+from os import path
+
+
+class PystranoConfig(object):
+    """A class to represent a Pystrano server configuration."""
+    def __init__(self):
+        self._config_finalized = False
+
+    def update_dict(self, data):
+        """Update the configuration with the given key-value pairs overwriting previous values."""
+        self.__dict__.update(**data)
+        self._clean()
+
+    def _clean(self):
+        """Clean up the configuration values for later use."""
+
+        # Convert ssh_known_hosts to a list
+        if hasattr(self, "ssh_known_hosts") and isinstance(getattr(self, "ssh_known_hosts"), str):
+            setattr(self, "ssh_known_hosts", getattr(self, "ssh_known_hosts", "").split(";"))
+
+        # Convert secrets to a list
+        if hasattr(self, "secrets") and isinstance(getattr(self, "secrets"), str):
+            setattr(self, "secrets", getattr(self, "secrets", "").split(";"))
+
+    def _load_env_file(self):
+        """Load the environment file and return the values as a dictionary."""
+        return dotenv_values(self.env_file)
+
+    def finalize_config(self):
+        """Finalize the configuration by cleaning up the values."""
+        if self._config_finalized:
+            return
+
+        # Mark the configuration as finalized so this method is not called again
+        self._config_finalized = True
+
+        self._clean()
+
+        if hasattr(self, "project_user") and hasattr(self, "project_root"):
+            setattr(self, "project_root", path.join("/home", self.project_user, self.project_root))
+            setattr(self, "releases_dir", path.join(self.project_root, "releases"))
+            setattr(self, "current_dir", path.join(self.project_root, "current"))
+            setattr(self, "shared_dir", path.join(self.project_root, "shared"))
+
+        if hasattr(self, "venv_dir"):
+            setattr(self, "venv_dir", path.join("/home", self.project_user, self.venv_dir))
+            setattr(self, "python_path", path.join(self.venv_dir, "bin", "python"))
+
+        if hasattr(self, "env_file"):
+            setattr(self, "env_vars", self._load_env_file())
+
+        if hasattr(self, "service_file"):
+            setattr(self, "service_file_name", path.basename(self.service_file))
+
+        if hasattr(self, "run_migrations"):
+            setattr(self, "run_migrations", self.run_migrations.lower() == "true")
+        else:
+            setattr(self, "run_migrations", False)
+
+        if hasattr(self, "collect_static_files"):
+            setattr(self, "collect_static_files", self.collect_static_files.lower() == "true")
+        else:
+            setattr(self, "collect_static_files", False)
+
+        if hasattr(self, "port"):
+            setattr(self, "port", int(self.port))
+        else:
+            setattr(self, "port", 22)
+
+
+
+def create_server_config(server_description: dict, common_config: dict) -> PystranoConfig:
+    """Create a Pystrano server configuration from the given server description and common configuration."""
+    config = PystranoConfig()
+
+    # Load common variables first
+    config.update_dict(common_config)
+
+    # Load server specific variables (potentially overwriting common variables)
+    config.update_dict(server_description)
+
+    # Finalize the configuration
+    config.finalize_config()
+
+    return config
+
+def load_config(config_path: str) -> list[PystranoConfig]:
+    """Load Pystrano server configurations from the given YAML config file."""
+    with open(config_path) as f:
+        config = safe_load(f)
+
+    # Get common configuration
+    common_config = config.pop("common")
+
+    # Create a cofinguration for each server
+    return [create_server_config(server, common_config) for server in config["servers"]]

pystrano/core.py

@@ -0,0 +1,151 @@
+from fabric import Connection
+from pystrano.config import PystranoConfig
+from os import path
+
+
+def setup_release_dir(connection: Connection, new_release_dir: str):
+    """Set up a new release directory on the server."""
+    connection.run(f'mkdir -p {new_release_dir}')
+
+
+def update_source_code(connection: Connection, new_release_dir: str, conf: PystranoConfig):
+    """Update the source code in the new release directory."""
+    connection.run(f'git clone {conf.source_code_url} {new_release_dir}')
+    connection.run(f'cd {new_release_dir} && git checkout {conf.branch}')
+
+
+def setup_symlinks(connection: Connection, new_release_dir: str, conf: PystranoConfig):
+    """Set up symlinks to shared directories."""
+    connection.run(f'ln -sfn {conf.shared_dir}/media {new_release_dir}/media')
+    connection.run(f'ln -sfn {conf.shared_dir}/.env.{new_release_dir.split("/")[-1]} {conf.shared_dir}/.env')
+
+
+def install_requirements(connection: Connection, new_release_dir: str, conf: PystranoConfig):
+    """Install dependencies in the virtual environment."""
+    with connection.cd(new_release_dir):
+        connection.run(f'{conf.venv_dir}/bin/pip install -r requirements.txt')
+
+
+def collect_static_files(connection: Connection, new_release_dir: str, conf: PystranoConfig):
+    """Collect static files to the shared directory."""
+    with connection.cd(new_release_dir):
+        connection.run(f'{conf.python_path} manage.py collectstatic --noinput', env=conf.env_vars)
+
+
+def migrate_database(connection: Connection, new_release_dir: str, conf: PystranoConfig):
+    """Apply migrations to the database."""
+    with connection.cd(new_release_dir):
+        connection.run(f'{conf.python_path} manage.py migrate', env=conf.env_vars)
+
+
+def update_symlink(connection: Connection, new_release_dir: str, conf: PystranoConfig):
+    """Update the `current` symlink to point to the new release."""
+    connection.run(f'ln -sfn {new_release_dir} {conf.current_dir}')
+
+
+def restart_service(connection: Connection, conf: PystranoConfig):
+    """Restart the Gunicorn service."""
+    connection.sudo(f'systemctl restart {conf.service_file_name}')
+
+
+def cleanup_old_releases(connection: Connection, conf: PystranoConfig):
+    """Remove old releases, keeping only the last `KEEP_RELEASES`."""
+
+    # Allow people to choose to keep all releases
+    if conf.keep_releases <= 0:
+        return
+
+    releases = connection.run(f'ls -1 {conf.releases_dir}', hide=True).stdout.split()
+
+    if len(releases) > conf.keep_releases:
+        old_releases = releases[:-conf.keep_releases]
+        for release in old_releases:
+            connection.run(f'rm -rf {conf.releases_dir}/{release}')
+
+
+def create_project_user(connection: Connection, conf: PystranoConfig):
+    """Set up a user if it does not exist."""
+
+    # Check if user exists
+    result = connection.run(f'id -u {conf.project_user}', warn=True)
+
+    if result.failed:
+        # Create user if it doesn't exist
+        connection.sudo(f'useradd -m -s /bin/bash {conf.project_user}')
+        # Allow sudo without password
+        connection.sudo(f'echo "{conf.project_user} ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/{conf.project_user}')
+
+
+def create_directory_structure(connection: Connection, conf: PystranoConfig):
+    """Create the directory structure on the server."""
+    connection.sudo(f'mkdir -p {conf.shared_dir}')
+    connection.sudo(f'mkdir -p {conf.releases_dir}')
+    connection.sudo(f'mkdir -p {conf.venv_dir}')
+    connection.sudo(f'chown -R {conf.project_user}:{conf.project_user} {conf.project_root}')
+
+
+def setup_packages(connection: Connection, conf: PystranoConfig):
+    """Install required packages on the server."""
+    connection.run('apt update')
+    connection.run('apt install -y python3 python3-venv python3-pip git')
+
+    # Install additional system packages if specified
+    if conf.system_packages:
+        connection.run(f'apt install -y {conf.system_packages}')
+
+
+def setup_venv(connection: Connection, conf: PystranoConfig):
+    """Set up a virtual environment."""
+    connection.run(f'python3 -m venv {conf.venv_dir}')
+    connection.run(f'chown -R {conf.project_user}:{conf.project_user} {conf.venv_dir}')
+
+
+def copy_authorized_keys(connection: Connection, conf: PystranoConfig):
+    """Copy the authorized keys to the project user's directory."""
+    connection.run(f'mkdir -p /home/{conf.project_user}/.ssh')
+    connection.run(f'cp ~/.ssh/authorized_keys /home/{conf.project_user}/.ssh/')
+    connection.run(f'chown -R {conf.project_user}:{conf.project_user} /home/{conf.project_user}/.ssh')
+
+
+def setup_known_hosts(connection: Connection, conf: PystranoConfig):
+    """Add known hosts to the project user's SSH configuration."""
+    connection.run(f'ssh-keyscan github.com >> /home/{conf.project_user}/.ssh/known_hosts')
+
+    for host in conf.ssh_known_hosts:
+        connection.run(f'ssh-keyscan {host} >> /home/{conf.project_user}/.ssh/known_hosts')
+
+    connection.run(f'chown {conf.project_user}:{conf.project_user} /home/{conf.project_user}/.ssh/known_hosts')
+
+
+def setup_service(connection: Connection, conf: PystranoConfig):
+    """Set up the service."""
+    connection.put(conf.service_file, f'/etc/systemd/system/{conf.service_file_name}')
+    connection.sudo('systemctl daemon-reload')
+    connection.sudo(f'systemctl enable {conf.service_file_name}')
+
+
+def try_to_remove_release_dir(connection: Connection, release_dir: str):
+    """Try to remove a release directory."""
+    try:
+        connection.run(f'rm -rf {release_dir}')
+    except Exception as e:
+        print(f"Error removing release directory: {e}")
+
+
+def copy_env_file(connection: Connection, new_release_dir: str, conf: PystranoConfig):
+    """Copy the environment file to the shared directory."""
+    connection.put(conf.env_file, f'{conf.shared_dir}/.env.{new_release_dir.split("/")[-1]}')
+
+
+def copy_secrets(connection: Connection, conf: PystranoConfig):
+    """Copy secrets to the shared directory."""
+    for secret in conf.secrets:
+        secret_file_name = path.basename(secret)
+        connection.put(secret, f'{conf.shared_dir}/{secret_file_name}')
+
+
+def link_secrets_to_release(connection: Connection, new_release_dir: str, conf: PystranoConfig):
+    """Link secrets to the release directory."""
+    for secret in conf.secrets:
+        secret_file_name = path.basename(secret)
+        connection.run(f'ln -sfn {conf.shared_dir}/{secret_file_name} {new_release_dir}/{secret_file_name}')

pystrano/deploy.py

@@ -0,0 +1,136 @@
+from fabric import Connection
+from datetime import datetime
+from click import command, option
+
+from .config import load_config, PystranoConfig
+from .core import (
+    setup_release_dir,
+    update_source_code,
+    setup_symlinks,
+    install_requirements,
+    collect_static_files,
+    migrate_database,
+    update_symlink,
+    restart_service,
+    cleanup_old_releases,
+    try_to_remove_release_dir,
+    create_project_user,
+    copy_authorized_keys,
+    create_directory_structure,
+    setup_packages,
+    setup_venv,
+    setup_known_hosts,
+    setup_service,
+    copy_env_file,
+    copy_secrets,
+    link_secrets_to_release,
+)
+
+
+def set_up(server_configurations: list[PystranoConfig]):
+    try:
+        for server_config in server_configurations:
+            print(f"Setting up {server_config.host}")
+            c = Connection(f"root@{server_config.host}", forward_agent=True, port=server_config.port)
+
+            print("Creating project user")
+            create_project_user(c, server_config)
+
+            print("Copy SSH keys from root")
+            copy_authorized_keys(c, server_config)
+
+            print("Creating directory structure")
+            create_directory_structure(c, server_config)
+
+            print("Install necessary packages")
+            setup_packages(c, server_config)
+
+            print("Setting up venv")
+            setup_venv(c, server_config)
+
+            print("Setting up known hosts")
+            setup_known_hosts(c, server_config)
+
+            if hasattr(server_config, "service_file"):
+                print("Setting up service that should be executed")
+                setup_service(c, server_config)
+
+            if hasattr(server_config, "secrets"):
+                print("Copying secrets to shared directory")
+                copy_secrets(c, server_config)
+    except Exception as e:
+        print(f"Error setting up: {e}")
+        exit(1)
+
+
+def deploy(server_configurations: list[PystranoConfig]):
+    timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
+
+    try:
+        for server_config in server_configurations:
+            new_release_dir = f"{server_config.releases_dir}/{timestamp}"
+
+            print(f"Deploying to {server_config.host}")
+            c = Connection(f"{server_config.project_user}@{server_config.host}", forward_agent=True, port=server_config.port)
+
+            print("Creating release directory")
+            setup_release_dir(c, new_release_dir)
+
+            print("Updating source code")
+            update_source_code(c, new_release_dir, server_config)
+
+            print("Copying environment file to shared directory")
+            copy_env_file(c, new_release_dir, server_config)
+
+            print("Setting up symlinks")
+            setup_symlinks(c, new_release_dir, server_config)
+
+            print("Installing requirements")
+            install_requirements(c, new_release_dir, server_config)
+
+            if hasattr(server_config, "secrets"):
+                print("Linking secrets to the release directory")
+                link_secrets_to_release(c, new_release_dir, server_config)
+
+            if hasattr(server_config, "collect_static_files") and server_config.collect_static_files:
+                print("Collecting static files")
+                collect_static_files(c, new_release_dir, server_config)
+
+            if hasattr(server_config, "run_migrations") and server_config.run_migrations:
+                print("Migrating database")
+                migrate_database(c, new_release_dir, server_config)
+
+            print("Updating symlinks")
+            update_symlink(c, new_release_dir, server_config)
+
+            if hasattr(server_config, "service_file"):
+                print("Restarting service")
+                restart_service(c, server_config)
+
+            print("Cleaning up old releases")
+            cleanup_old_releases(c, server_config)
+    except Exception as e:
+        print(f"Error deploying: {e}")
+        exit(1)
+
+
+@command()
+@option('--config-file', required=True, help='Path to the configuration file')
+def main(config_file):
+    try:
+        server_configurations = load_config(config_file)
+        deploy(server_configurations)
+    except Exception as e:
+        print(f"Error deploying servers: {e}")
+        exit(1)
+
+
+@command()
+@option('--config-file', required=True, help='Path to the configuration file')
+def setup(config_file):
+    try:
+        server_configurations = load_config(config_file)
+        set_up(server_configurations)
+    except Exception as e:
+        print(f"Error setting up servers: {e}")
+        exit(1)

pystrano-1.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 lexpank
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pystrano-1.0.0.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.1
+Name: pystrano
+Version: 1.0.0
+Summary: A Python package for managing deploying Django applications (like Capistrano for Ruby)
+Home-page: https://github.com/lexpank/pystrano
+License: MIT License
+        
+        Copyright (c) 2024 lexpank
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: homepage, https://github.com/lexpank/pystrano
+Project-URL: issues, https://github.com/lexpank/pystrano/issues
+Keywords: pystrano
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11 
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fabric<4.0,>=3.2.2
+Requires-Dist: click<9.0,>=8.1.7
+Requires-Dist: pyyaml<7.0,>=6.0.2
+Requires-Dist: python-dotenv<2.0,>=1.0.1
+
+# Pystrano
+
+Pystrano is a simple deployment tool for Python projects.
+It is inspired by Capistrano, a popular deployment tool for
+Ruby projects.
+
+## Disclaimer
+
+This is a work in progress. It is not ready for production use
+just yet. Proceed with caution. Currently used with Ubuntu
+by yours truly. If someone finds it useful and wants to use it
+in any capacity, don't hesitate.
+
+## Installation
+
+```bash
+pip install pystrano
+```
+
+## Usage
+
+Pystrano is a command line tool. To deploy a project, you need
+to create a config for the environment you want to deploy to.
+
+### Configuration
+
+Pystrano uses a YAML file to configure the deployment. It contains two sections: `common` and `servers`. Variables in `common` section are shared across all servers, while in `servers` section you define a list of servers to deploy to. It is also possible to define server-specific variables, which will override the common ones (if defined).
+
+Here is a description of variables you can set in the config file:
+
+- `source_code_url`: The URL of the git repository;
+- `project_root`: The directory where the project is located;
+- `project_user`: The user that will be used to deploy the project;
+- `venv_dir`: The directory where the virtual environment is located (in the `project_user` home);
+- `keep_releases`: The number of releases to keep on the server. If set to 0 or less, all releases will be kept;
+- `system_packages`: A list of system packages to install on the server (during setup);
+- `env_file`: The path to the environment file to use for the deployment;
+- `ssh_known_hosts`: The path to the known hosts file to use for the deployment  (during setup; separated by semicolons);
+- `service_file`: The path to the service file to set up/use in deployment (optional);
+- `secrets`: List of secrets to set up on the server (during setup only for now; separated by semicolons);
+- `branch`: The name of the branch to deploy.
+
+Server-specific variables:
+
+- `host`: The hostname of the server;
+- `port`: The port to use for SSH connection (optional, default is 22);
+- `run_migrations`: Whether to run migrations on deployment (optional, default is false);
+- `run_collectstatic`: Whether to run collectstatic on deployment (optional, default is false);
+
+### Deployment
+
+To set up deployment for a project, run the following command:
+
+```bash
+pystrano-setup --config-file=path/to/config.yml
+```
+
+This will set up your server to be ready for deployment.
+
+To deploy your project, run the following command:
+
+```bash
+pystrano --config-file=path/to/config.yml
+```

pystrano-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pystrano/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pystrano/config.py,sha256=Kh33h_c9f-5AO_TILCPTfF5SaekmkUWqeOB98Kfz39g,3735
+pystrano/core.py,sha256=wZG008eethJ03yLoZ3jFTNyuBXqVBZRPP4R9k5PaUqA,6442
+pystrano/deploy.py,sha256=GElWW1EZcqnZVClrWBdx0mIUH7O0FpV_AwS4UQZF8JA,4545
+pystrano-1.0.0.dist-info/LICENSE,sha256=l6v4VVqOnAz93I_4Bb9HiAV7JXqtvvCTWPuGlLy2pE0,1064
+pystrano-1.0.0.dist-info/METADATA,sha256=CfsYtxjWuf1FnBj7OoPDbeC1iX_sfe6QfYnp46cRVx8,4647
+pystrano-1.0.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pystrano-1.0.0.dist-info/entry_points.txt,sha256=5ajtKw_Tra0lLniOJPusScU-snuASzHShg17XVGLcnc,89
+pystrano-1.0.0.dist-info/top_level.txt,sha256=ib6v34d04Rjf5KOe0anUVg0ZhAvbcCMV8hrYWKm5jiE,9
+pystrano-1.0.0.dist-info/RECORD,,

pystrano-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pystrano-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pystrano = pystrano.deploy:main
+pystrano-setup = pystrano.deploy:setup

pystrano-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pystrano