dsd-upsun 0.1.0__py3-none-any.whl

dsd_upsun/__init__.py

@@ -0,0 +1,2 @@
+from .deploy import dsd_get_plugin_config
+from .deploy import dsd_deploy

dsd_upsun/deploy.py

@@ -0,0 +1,20 @@
+"""Manages all Upsun-specific aspects of the deployment process."""
+
+import django_simple_deploy
+
+from dsd_upsun.platform_deployer import PlatformDeployer
+from .plugin_config import PluginConfig
+
+
+@django_simple_deploy.hookimpl
+def dsd_get_plugin_config():
+    """Get platform-specific attributes needed by core."""
+    plugin_config = PluginConfig()
+    return plugin_config
+
+
+@django_simple_deploy.hookimpl
+def dsd_deploy():
+    """Carry out platform-specific deployment steps."""
+    platform_deployer = PlatformDeployer()
+    platform_deployer.deploy()

dsd_upsun/deploy_messages.py

@@ -0,0 +1,208 @@
+"""A collection of messages used in platform_deployer.py."""
+
+# For conventions, see documentation in deploy_messages.py
+
+from textwrap import dedent
+
+from django.conf import settings
+
+
+confirm_automate_all = """
+The --automate-all flag means the deploy command will:
+- Run `upsun create` for you, to create an empty Upsun project.
+  - This will create a project in the us-3.platform.sh region. If you wish
+    to use a different region, cancel this operation and use the --region flag.
+  - You can see a list of all regions at:
+    https://docs.upsun.com/development/regions.html#region-location
+- Commit all changes to your project that are necessary for deployment.
+- Push these changes to Upsun.
+- Open your deployed project in a new browser tab.
+"""
+
+cancel_upsun = """
+Okay, cancelling Upsun deployment.
+"""
+
+cli_not_installed = """
+In order to deploy to Upsun, you need to install the Upsun CLI.
+  See here: https://docs.upsun.com/administration/cli.html
+After installing the CLI, you can run the deploy command again.
+"""
+
+cli_logged_out = """
+You are currently logged out of the Upsun CLI. Please log in,
+  and then run the deploy command again.
+You can log in from  the command line:
+  $ platform login
+"""
+
+upsun_settings_found = """
+There is already an Upsun-specific settings block in settings.py. Is it okay to
+overwrite this block, and everything that follows in settings.py?
+"""
+
+cant_overwrite_settings = """
+In order to configure the project for deployment, we need to write an Upsun-specific
+settings block. Please remove the current Upsun-specific settings, and then run
+the deploy command again.
+"""
+
+no_project_name = """
+An Upsun project name could not be found.
+
+The deploy command expects that you've already run `platform create`, or
+associated the local project with an existing project on Upsun.
+
+If you haven't done so, run the `platform create` command and then run
+the deploy command again. You can override this warning by using
+the `--deployed-project-name` flag to specify the name you want to use for the
+project. This must match the name of your Upsun project.
+"""
+
+org_not_found = """
+An Upsun organization name could not be found.
+
+You may have created an Upsun account, but not created an organization.
+The Upsun CLI requires an organization name when creating a new project.
+
+Please visit the Upsun console and make sure you have created an organization.
+You can also do this through the CLI using the `platform organization:create` command.
+For help, run `platform help organization:create`.
+"""
+
+no_org_available = """
+An Upsun org must be used to make a deployment. Please identify or create the org
+you'd like to use, and then try again.
+"""
+
+login_required = """
+You appear to be logged out of the Upsun CLI. Please run the 
+command `platform login`, and then run the deploy command again.
+
+You may be able to override this error by passing the `--deployed-project-name`
+flag.
+"""
+
+unknown_error = """
+An unknown error has occurred. Do you have the Upsun CLI installed?
+"""
+
+may_configure = """
+You may want to re-run the deploy command without the --automate-all flag.
+
+You will have to create the Upsun project yourself, but django-simple-deploy
+will do all of the necessary configuration for deployment.
+"""
+
+
+# --- Dynamic strings ---
+# These need to be generated in functions, to display information that's
+#   determined as the script runs.
+
+
+def confirm_use_org(org_name):
+    """Confirm use of this org to create a new project."""
+
+    msg = dedent(
+        f"""
+        --- The Upsun CLI requires an organization name when creating a new project. ---
+        When using --automate-all, a project will be created on your behalf. The following
+        organization was found: {org_name}
+
+        This organization will be used to create a new project. If this is not okay,
+        enter n to cancel this operation.
+    """
+    )
+
+    return msg
+
+
+def unknown_create_error(e):
+    """Process a non-specific error when running `platform create`
+    while using automate_all. This is most likely an issue with the user
+    not having permission to create a new project, for example because they
+    are on a trial plan and have already created too many projects.
+    """
+
+    msg = dedent(
+        f"""
+        --- An error has occurred when trying to create a new Upsun project. ---
+
+        While running `platform create`, an error has occurred. You should check
+        the Upsun console to see if a project was partially created.
+
+        The error messages that Upsun provides, both through the CLI and
+        the console, are not always specific enough to be helpful. For example, 
+        newer users are limited to two new projects in a 24-hour period, or something
+        like that. But if you try to create an additional project, you only get
+        a message that says: "You do not have access to create a new Subscriptions resource".
+        There is no information about specific limits, and how to address them.
+
+        The following output may help diagnose the error:
+        ***** output of `platform create` *****
+
+        {e.stderr.decode()}
+
+        ***** end output *****
+    """
+    )
+
+    return msg
+
+
+def success_msg(log_output=""):
+    """Success message, for configuration-only run."""
+
+    msg = dedent(
+        f"""
+        --- Your project is now configured for deployment on Upsun. ---
+
+        To deploy your project, you will need to:
+        - Commit the changes made in the configuration process.
+            $ git status
+            $ git add .
+            $ git commit -am "Configured project for deployment."
+        - Push your project to Upsun' servers:
+            $ platform push
+        - Open your project:
+            $ platform url    
+        - As you develop your project further:
+            - Make local changes
+            - Commit your local changes
+            - Run `platform push`
+    """
+    )
+
+    if log_output:
+        msg += dedent(
+            f"""
+        - You can find a full record of this configuration in the dsd_logs directory.
+        """
+        )
+
+    return msg
+
+
+def success_msg_automate_all(deployed_url):
+    """Success message, when using --automate-all."""
+
+    msg = dedent(
+        f"""
+
+        --- Your project should now be deployed on Upsun. ---
+
+        It should have opened up in a new browser tab.
+        - You can also visit your project at {deployed_url}
+
+        If you make further changes and want to push them to Upsun,
+        commit your changes and then run `platform push`.
+
+        Also, if you haven't already done so you should review the
+        documentation for Python deployments on Upsun at:
+        - https://fixed.docs.upsun.com/languages/python.html
+        - This documentation will help you understand how to maintain
+          your deployment.
+
+    """
+    )
+    return msg

dsd_upsun/platform_deployer.py

@@ -0,0 +1,411 @@
+"""Manages all Upsun-specific aspects of the deployment process."""
+
+import sys, os, subprocess, time
+from pathlib import Path
+
+from django.conf import settings
+from django.core.management.utils import get_random_secret_key
+from django.utils.crypto import get_random_string
+from django.utils.safestring import mark_safe
+
+from django_simple_deploy.management.commands.utils import plugin_utils
+from django_simple_deploy.management.commands.utils.plugin_utils import dsd_config
+from django_simple_deploy.management.commands.utils.command_errors import (
+    DSDCommandError,
+)
+
+from . import deploy_messages as upsun_msgs
+from . import utils as upsun_utils
+
+
+class PlatformDeployer:
+    """Perform the initial deployment to Upsun.
+
+    If --automate-all is used, carry out an actual deployment.
+    If not, do all configuration work so the user only has to commit changes, and call
+    `upsun push`.
+    """
+
+    def __init__(self):
+        self.templates_path = Path(__file__).parent / "templates"
+
+    # --- Public methods ---
+
+    def deploy(self, *args, **options):
+        """Coordinate the overall configuration and deployment."""
+        plugin_utils.write_output(
+            "\nConfiguring project for deployment to Upsun..."
+        )
+
+        self._validate_platform()
+
+        self._prep_automate_all()
+        self._modify_settings()
+        self._add_requirements()
+        self._add_platform_app_yaml()
+        self._add_platform_dir()
+        self._add_services_yaml()
+        self._settings_env_var()
+
+        self._conclude_automate_all()
+        self._show_success_message()
+
+    # --- Helper methods for deploy() ---
+
+    def _validate_platform(self):
+        """Make sure the local environment and project supports deployment to
+        Upsun.
+
+        Make sure CLI is installed, and user is authenticated. Make sure necessary
+        resources have been created and identified, and that we have the user's
+        permission to use those resources.
+
+        Returns:
+            None
+
+        Raises:
+            DSDCommandError: If we find any reason deployment won't work.
+        """
+        if dsd_config.unit_testing:
+            # Unit tests don't use the CLI. Use the deployed project name that was
+            # passed to the simple_deploy CLI.
+            self.deployed_project_name = dsd_config.deployed_project_name
+            plugin_utils.log_info(
+                f"Deployed project name: {self.deployed_project_name}"
+            )
+            return
+
+        self._check_upsun_settings()
+        self._validate_cli()
+
+        self.deployed_project_name = self._get_upsun_project_name()
+        plugin_utils.log_info(f"Deployed project name: {self.deployed_project_name}")
+
+        self.org_name = self._get_org_name()
+        plugin_utils.log_info(f"\nOrg name: {self.org_name}")
+
+    def _prep_automate_all(self):
+        """Intial work for automating entire process.
+
+        Returns:
+            None: If creation of new project was successful.
+
+        Raises:
+            DSDCommandError: If create command fails.
+
+        Note: create command outputs project id to stdout if known, all other
+          output goes to stderr.
+        """
+        if not dsd_config.automate_all:
+            return
+
+        plugin_utils.write_output("  Running `upsun create`...")
+        plugin_utils.write_output(
+            "    (Please be patient, this can take a few minutes."
+        )
+        cmd = f"upsun create --title { self.deployed_project_name } --org {self.org_name} --region {dsd_config.region} --yes"
+
+        try:
+            # Note: if user can't create a project the returncode will be 6, not 1.
+            #   This may affect whether a CompletedProcess is returned, or an Exception
+            # is raised.
+            # Also, create command outputs project id to stdout if known, all other
+            # output goes to stderr.
+            plugin_utils.run_slow_command(cmd)
+        except subprocess.CalledProcessError as e:
+            error_msg = upsun_msgs.unknown_create_error(e)
+            raise DSDCommandError(error_msg)
+
+    def _modify_settings(self):
+        """Add upsun-specific settings.
+
+        This settings block is currently the same for all users. The ALLOWED_HOSTS
+        setting should be customized.
+        """
+        template_path = self.templates_path / "settings.py"
+        plugin_utils.modify_settings_file(template_path)
+
+    def _add_platform_app_yaml(self):
+        """Add a .platform.app.yaml file."""
+
+        # Build contents from template.
+        if dsd_config.pkg_manager == "poetry":
+            template_path = "poetry.platform.app.yaml"
+        elif dsd_config.pkg_manager == "pipenv":
+            template_path = "pipenv.platform.app.yaml"
+        else:
+            template_path = "platform.app.yaml"
+        template_path = self.templates_path / template_path
+
+        context = {
+            "project_name": dsd_config.local_project_name,
+            "deployed_project_name": self.deployed_project_name,
+        }
+
+        contents = plugin_utils.get_template_string(template_path, context)
+
+        # Write file to project.
+        path = dsd_config.project_root / ".platform.app.yaml"
+        plugin_utils.add_file(path, contents)
+
+    def _add_requirements(self):
+        """Add requirements for Upsun."""
+        requirements = ["platformshconfig", "gunicorn", "psycopg2"]
+        plugin_utils.add_packages(requirements)
+
+    def _add_platform_dir(self):
+        """Add a .platform directory, if it doesn't already exist."""
+        self.platform_dir_path = dsd_config.project_root / ".platform"
+        plugin_utils.add_dir(self.platform_dir_path)
+
+    def _add_services_yaml(self):
+        """Add the .platform/services.yaml file."""
+
+        template_path = self.templates_path / "services.yaml"
+        contents = plugin_utils.get_template_string(template_path, context=None)
+
+        path = self.platform_dir_path / "services.yaml"
+        plugin_utils.add_file(path, contents)
+
+    def _settings_env_var(self):
+        """Set the DJANGO_SETTINGS_MODULE env var, if needed."""
+        # This is primarily for Wagtail projects, as signified by a settings/production.py file.
+        if dsd_config.settings_path.parts[-2:] == ("settings", "production.py"):
+            plugin_utils.write_output("  Setting DJANGO_SETTINGS_MODULE environment variable...")
+
+            # Need form mysite.settings.production
+            dotted_settings_path = ".".join(dsd_config.settings_path.parts[-3:]).removesuffix(".py")
+
+            cmd = f"upsun variable:create --level environment --environment main --name DJANGO_SETTINGS_MODULE --value {dotted_settings_path} --no-interaction --visible-build true --prefix env"
+            output = plugin_utils.run_quick_command(cmd)
+            plugin_utils.write_output(output)
+
+    def _conclude_automate_all(self):
+        """Finish automating the push to Upsun.
+
+        - Commit all changes.
+        - Call `upsun push`.
+        - Open project.
+        """
+        # Making this check here lets deploy() be cleaner.
+        if not dsd_config.automate_all:
+            return
+
+        plugin_utils.commit_changes()
+
+        # Push project.
+        plugin_utils.write_output("  Pushing to Upsun...")
+
+        # Pause to make sure project that was just created can be used.
+        plugin_utils.write_output(
+            "    Pausing 10s to make sure project is ready to use..."
+        )
+        time.sleep(10)
+
+        # Use run_slow_command(), to stream output as it runs.
+        cmd = "upsun push --yes"
+        plugin_utils.run_slow_command(cmd)
+
+        # Open project.
+        plugin_utils.write_output("  Opening deployed app in a new browser tab...")
+        cmd = "upsun url --yes"
+        output = plugin_utils.run_quick_command(cmd)
+        plugin_utils.write_output(output)
+
+        # Get url of deployed project.
+        #   This can be done with an re, but there's one line of output with
+        #   a url, so finding that line is simpler.
+        # DEV: Move this to a utility, and write a test against standard Upsun
+        # output.
+        self.deployed_url = ""
+        for line in output.stdout.decode().split("\n"):
+            if "https" in line:
+                self.deployed_url = line.strip()
+
+    def _show_success_message(self):
+        """After a successful run, show a message about what to do next."""
+
+        # DEV:
+        # - Mention that this script should not need to be run again unless creating
+        #   a new deployment.
+        # - Describe ongoing approach of commit, push, migrate. Lots to consider
+        #   when doing this on production app with users, make sure you learn.
+
+        if dsd_config.automate_all:
+            msg = upsun_msgs.success_msg_automate_all(self.deployed_url)
+            plugin_utils.write_output(msg)
+        else:
+            msg = upsun_msgs.success_msg(dsd_config.log_output)
+            plugin_utils.write_output(msg)
+
+    # --- Helper methods for methods called from deploy.py ---
+
+    def _check_upsun_settings(self):
+        """Check to see if an Upsun settings block already exists."""
+        start_line = "# Upsun settings."
+        plugin_utils.check_settings(
+            "Upsun",
+            start_line,
+            upsun_msgs.upsun_settings_found,
+            upsun_msgs.cant_overwrite_settings,
+        )
+
+    def _validate_cli(self):
+        """Make sure the Upsun CLI is installed, and user is authenticated."""
+        cmd = "upsun --version"
+
+        # This generates a FileNotFoundError on Ubuntu if the CLI is not installed.
+        try:
+            output_obj = plugin_utils.run_quick_command(cmd)
+        except FileNotFoundError:
+            raise DSDCommandError(upsun_msgs.cli_not_installed)
+
+        plugin_utils.log_info(output_obj)
+
+        # Check that the user is authenticated.
+        cmd = "upsun auth:info --no-interaction"
+        output_obj = plugin_utils.run_quick_command(cmd)
+
+        if "Authentication is required." in output_obj.stderr.decode():
+            raise DSDCommandError(upsun_msgs.cli_logged_out)
+
+    def _get_upsun_project_name(self):
+        """Get the deployed project name.
+
+        If using automate_all, we'll set this. Otherwise, we're looking for the name
+        that was given in the `upsun create` command.
+        - Try to get this from `project:info`.
+        - If can't get project name:
+          - Exit with warning, and inform user of --deployed-project-name
+            flag to override this error.
+
+        Retuns:
+            str: The deployed project name.
+        Raises:
+            DSDCommandError: If deployed project name can't be found.
+        """
+        # If we're creating the project, we'll just use the startproject name.
+        if dsd_config.automate_all:
+            return dsd_config.local_project_name
+
+        # Use the provided name if --deployed-project-name specified.
+        if dsd_config.deployed_project_name:
+            return dsd_config.deployed_project_name
+
+        # Use --yes flag to avoid interactive prompt hanging in background
+        #   if the user is not currently logged in to the CLI.
+        cmd = "upsun project:info --yes --format csv"
+        output_obj = plugin_utils.run_quick_command(cmd)
+        output_str = output_obj.stdout.decode()
+
+        # Log cmd, but don't log the output of `project:info`. It contains identifying
+        # information about the user and project, including client_ssh_key.
+        plugin_utils.log_info(cmd)
+
+        # If there's no stdout, the user is probably logged out, hasn't called
+        #   create, or doesn't have the CLI installed.
+        # Also, I've seen both ProjectNotFoundException and RootNotFoundException
+        #   raised when no project has been created.
+        if not output_str:
+            output_str = output_obj.stderr.decode()
+            if "LoginRequiredException" in output_str:
+                raise DSDCommandError(upsun_msgs.login_required)
+            elif "ProjectNotFoundException" in output_str:
+                raise DSDCommandError(upsun_msgs.no_project_name)
+            elif "RootNotFoundException" in output_str:
+                raise DSDCommandError(upsun_msgs.no_project_name)
+            else:
+                error_msg = upsun_msgs.unknown_error
+                error_msg += upsun_msgs.cli_not_installed
+                raise DSDCommandError(error_msg)
+
+        # Pull deployed project name from output.
+        lines = output_str.splitlines()
+        title_line = [line for line in lines if "title," in line][0]
+        # Assume first project is one to use.
+        project_name = title_line.split(",")[1].strip()
+        project_name = upsun_utils.get_project_name(output_str)
+
+        # Project names can only have lowercase alphanumeric characters.
+        # See: https://github.com/ehmatthes/django-simple-deploy/issues/323
+        if " " in project_name:
+            project_name = project_name.replace(" ", "_").lower()
+        if project_name:
+            return project_name
+
+        # Couldn't find a project name. Warn user, and tell them about override flag.
+        raise DSDCommandError(upsun_msgs.no_project_name)
+
+    def _get_org_name(self):
+        """Get the organization name associated with the user's Upsun account.
+
+        This is needed for creating a project using automate_all.
+        Confirm that it's okay to use this org.
+
+        Returns:
+            str: org name
+            None: if not using automate-all
+        Raises:
+            DSDCommandError:
+            - if org name found, but not confirmed.
+            - if org name not found
+        """
+        if not dsd_config.automate_all:
+            return
+
+        cmd = "upsun organization:list --yes --format csv"
+        output_obj = plugin_utils.run_quick_command(cmd)
+        output_str = output_obj.stdout.decode()
+        plugin_utils.log_info(output_str)
+
+        org_names = upsun_utils.get_org_names(output_str)
+        if not org_names:
+            raise DSDCommandError(upsun_msgs.org_not_found)
+
+        if len(org_names) == 1:
+            # Get permission to use this org.
+            org_name = org_names[0]
+            if self._confirm_use_org(org_name):
+                return org_name
+
+        # Show all orgs, ask user to make selection.
+        prompt = "\n*** Found multiple orgs on Upsun. ***"
+        for index, name in enumerate(org_names):
+            prompt += f"\n  {index}: {name}"
+        prompt += "\nWhich org would you like to use? "
+
+        valid_choices = [i for i in range(len(org_names))]
+
+        # Confirm selection, because we do *not* want to deploy using the wrong org.
+        confirmed = False
+        while not confirmed:
+            selection = plugin_utils.get_numbered_choice(
+                prompt, valid_choices, upsun_msgs.no_org_available
+            )
+            selected_org = org_names[selection]
+
+            confirm_prompt = f"You have selected {selected_org}."
+            confirm_prompt += " Is that correct?"
+            confirmed = plugin_utils.get_confirmation(confirm_prompt)
+
+            return selected_org
+
+    def _confirm_use_org(self, org_name):
+        """Confirm that it's okay to use the org that was found.
+
+        Returns:
+            True: if confirmed
+            DSDCommandError: if not confirmed
+        """
+
+        dsd_config.stdout.write(upsun_msgs.confirm_use_org(org_name))
+        confirmed = plugin_utils.get_confirmation(skip_logging=True)
+
+        if confirmed:
+            dsd_config.stdout.write("  Okay, continuing with deployment.")
+            return True
+        else:
+            # Exit, with a message that configuration is still an option.
+            msg = upsun_msgs.cancel_upsun
+            msg += upsun_msgs.may_configure
+            raise DSDCommandError(msg)

dsd_upsun/plugin_config.py

@@ -0,0 +1,27 @@
+"""Config class for plugin information shared with core."""
+
+from . import deploy_messages as upsun_msgs
+
+
+class PluginConfig:
+    """Class for managing attributes that need to be shared with core.
+
+    This is similar to the class DSDConfig in core's dsd_config.py.
+
+    This should future-proof plugins somewhat, in that if more information needs
+    to be shared back to core, it can be added here without breaking changes to the
+    core-plugin interface.
+
+    Get plugin-specific attributes required by core.
+
+    Required:
+    - automate_all_supported
+    - platform_name
+    Optional:
+    - confirm_automate_all_msg (required if automate_all_supported is True)
+    """
+
+    def __init__(self):
+        self.automate_all_supported = True
+        self.confirm_automate_all_msg = upsun_msgs.confirm_automate_all
+        self.platform_name = "Upsun"

dsd_upsun/templates/pipenv.platform.app.yaml

@@ -0,0 +1,62 @@
+# This file describes an application. You can have multiple applications
+# in the same project.
+#
+# See https://fixed.docs.upsun.com/create-apps.html
+
+# The name of this app. Must be unique within a project.
+name: '{{ deployed_project_name }}'
+
+# The runtime the application uses.
+type: 'python:3.10'
+
+# The relationships of the application with services or other applications.
+#
+# The left-hand side is the name of the relationship as it will be exposed
+# to the application in the PLATFORM_RELATIONSHIPS variable. The right-hand
+# side is in the form `<service name>:<endpoint name>`.
+relationships:
+    database: "db:postgresql"
+
+# The configuration of app when it is exposed to the web.
+web:
+    # Whether your app should speak to the webserver via TCP or Unix socket
+    # https://fixed.docs.upsun.com/guides/django/deploy/configure.html#how-to-start-your-app
+    upstream:
+        socket_family: unix
+    # Commands are run once after deployment to start the application process.
+    commands:
+        start: "pipenv run gunicorn -w 4 -b unix:$SOCKET {{ project_name }}.wsgi:application"
+    locations:
+        "/":
+            passthru: true
+        "/static":
+            root: "static"
+            expires: 1h
+            allow: true
+
+# The size of the persistent disk of the application (in MB).
+disk: 512
+
+# Set a local R/W mount for logs
+mounts:
+    'logs':
+        source: local
+        source_path: logs
+
+# The hooks executed at various points in the lifecycle of the application.
+hooks:
+  # The build hook runs before the application is deployed, and is useful for
+  # assembling the codebase.
+  # DEV: Why remove logs right after making them?
+  #      Also, may want to split requirements into requirements.txt and requirements_remote.txt.
+  build: |
+    pip install --upgrade pip
+    pip install pipenv
+    pipenv install
+
+    mkdir logs
+    pipenv run python manage.py collectstatic
+    rm -rf logs
+  deploy: |
+    pipenv run python manage.py migrate
+    

dsd_upsun/templates/platform.app.yaml

@@ -0,0 +1,60 @@
+# This file describes an application. You can have multiple applications
+# in the same project.
+#
+# See https://fixed.docs.upsun.com/create-apps.html
+
+# The name of this app. Must be unique within a project.
+name: '{{ deployed_project_name }}'
+
+# The runtime the application uses.
+type: 'python:3.12'
+
+# The relationships of the application with services or other applications.
+#
+# The left-hand side is the name of the relationship as it will be exposed
+# to the application in the PLATFORM_RELATIONSHIPS variable. The right-hand
+# side is in the form `<service name>:<endpoint name>`.
+relationships:
+    database: "db:postgresql"
+
+# The configuration of app when it is exposed to the web.
+web:
+    # Whether your app should speak to the webserver via TCP or Unix socket
+    # https://fixed.docs.upsun.com/guides/django/deploy/configure.html#how-to-start-your-app
+    upstream:
+        socket_family: unix
+    # Commands are run once after deployment to start the application process.
+    commands:
+        start: "gunicorn -w 4 -b unix:$SOCKET {{ project_name }}.wsgi:application"
+    locations:
+        "/":
+            passthru: true
+        "/static":
+            root: "static"
+            expires: 1h
+            allow: true
+
+# The size of the persistent disk of the application (in MB).
+disk: 512
+
+# Set a local R/W mount for logs
+mounts:
+    'logs':
+        source: local
+        source_path: logs
+
+# The hooks executed at various points in the lifecycle of the application.
+hooks:
+  # The build hook runs before the application is deployed, and is useful for
+  # assembling the codebase.
+  # DEV: Why remove logs right after making them?
+  #      Also, may want to split requirements into requirements.txt and requirements_remote.txt.
+  build: |
+    pip install --upgrade pip
+    pip install -r requirements.txt
+
+    mkdir logs
+    python manage.py collectstatic
+    rm -rf logs
+  deploy: |
+    python manage.py migrate

dsd_upsun/templates/poetry.platform.app.yaml

@@ -0,0 +1,74 @@
+# This file describes an application. You can have multiple applications
+# in the same project.
+#
+# See https://fixed.docs.upsun.com/create-apps.html
+
+# The name of this app. Must be unique within a project.
+name: '{{ deployed_project_name }}'
+
+# The runtime the application uses.
+type: 'python:3.10'
+
+# Set properties for poetry.
+variables:
+    env:
+        POETRY_VERSION: '1.3.1'
+        POETRY_VIRTUALENVS_IN_PROJECT: true
+        POETRY_VIRTUALENVS_CREATE: false
+
+# The relationships of the application with services or other applications.
+#
+# The left-hand side is the name of the relationship as it will be exposed
+# to the application in the PLATFORM_RELATIONSHIPS variable. The right-hand
+# side is in the form `<service name>:<endpoint name>`.
+relationships:
+    database: "db:postgresql"
+
+# The configuration of app when it is exposed to the web.
+web:
+    # Whether your app should speak to the webserver via TCP or Unix socket
+    # https://fixed.docs.upsun.com/guides/django/deploy/configure.html#how-to-start-your-app
+    upstream:
+        socket_family: unix
+    # Commands are run once after deployment to start the application process.
+    commands:
+        start: "/app/.local/bin/poetry run gunicorn -w 4 -b unix:$SOCKET {{ project_name }}.wsgi:application"
+    locations:
+        "/":
+            passthru: true
+        "/static":
+            root: "static"
+            expires: 1h
+            allow: true
+
+# The size of the persistent disk of the application (in MB).
+disk: 512
+
+# Set a local R/W mount for logs
+mounts:
+    'logs':
+        source: local
+        source_path: logs
+
+# The hooks executed at various points in the lifecycle of the application.
+hooks:
+  # The build hook runs before the application is deployed, and is useful for
+  # assembling the codebase.
+  # DEV: Why remove logs right after making them?
+  #      Also, may want to split requirements into requirements.txt and requirements_remote.txt.
+  build: |
+    set -e
+    pip install --upgrade pip
+    export PIP_USER=false
+    curl -sSL https://install.python-poetry.org | python3 - --version $POETRY_VERSION
+    export PIP_USER=true
+    /app/.local/bin/poetry lock
+    /app/.local/bin/poetry export -f requirements.txt --output requirements.txt --without-hashes --with deploy
+    pip install -r requirements.txt
+
+    mkdir logs
+    python manage.py collectstatic
+    rm -rf logs
+  deploy: |
+    python manage.py migrate
+    

dsd_upsun/templates/services.yaml

@@ -0,0 +1,11 @@
+
+# The services of the project.
+#
+# Each service listed will be deployed in its own container as part of your
+# Platform.sh project.
+#
+# See https://fixed.docs.upsun.com/add-services.html
+
+db:
+    type: postgresql:16
+    disk: 1024

dsd_upsun/templates/settings.py

@@ -0,0 +1,41 @@
+{{current_settings}}
+
+# Upsun settings.
+import os
+
+if os.environ.get("PLATFORM_APPLICATION_NAME"):
+    # Import some Upsun settings from the environment.
+    from platformshconfig import Config
+
+    config = Config()
+
+    try:
+        ALLOWED_HOSTS.append("*")
+    except NameError:
+        ALLOWED_HOSTS = ["*"]
+        
+    DEBUG = False
+
+    STATIC_URL = "/static/"
+
+    if config.appDir:
+        STATIC_ROOT = os.path.join(config.appDir, "static")
+    if config.projectEntropy:
+        SECRET_KEY = config.projectEntropy
+
+    if not config.in_build():
+        db_settings = config.credentials("database")
+        DATABASES = {
+            "default": {
+                "ENGINE": "django.db.backends.postgresql",
+                "NAME": db_settings["path"],
+                "USER": db_settings["username"],
+                "PASSWORD": db_settings["password"],
+                "HOST": db_settings["host"],
+                "PORT": db_settings["port"],
+            },
+            "sqlite": {
+                "ENGINE": "django.db.backends.sqlite3",
+                "NAME": os.path.join(BASE_DIR, "db.sqlite3"),
+            },
+        }

dsd_upsun/utils.py

@@ -0,0 +1,36 @@
+"""Utilities specific to Upsun deployments."""
+
+
+def get_project_name(output_str):
+    """Get the project name from the output of `upsun project:info`.
+
+    Command is run with `--format csv` flag.
+
+    Returns:
+        str: project name
+    """
+    lines = output_str.splitlines()
+    title_line = [line for line in lines if "title," in line][0]
+    # Assume first project is one to use.
+    project_name = title_line.split(",")[1].strip()
+
+    return project_name
+
+
+def get_org_names(output_str):
+    """Get org names from output of `upsun organization:list --yes --format csv`.
+
+    Sample input:
+        Name,Label,Owner email
+        <org-name>,<org-label>,<org-owner@example.com>
+        <org-name-2>,<org-label-2>,<org-owner-2@example.com>
+
+    Returns:
+        list: [str]
+        None: If user has no organizations.
+    """
+    if "No organizations found." in output_str:
+        return None
+
+    lines = output_str.split("\n")[1:]
+    return [line.split(",")[0] for line in lines if line]

dsd_upsun-0.1.0.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: dsd-upsun
+Version: 0.1.0
+Summary: A plugin for django-simple-deploy, supporting deployments to Upsun.
+Author-email: Eric Matthes <ehmatthes@gmail.com>
+Project-URL: Documentation, https://github.com/django-simple-deploy/dsd-upsun
+Project-URL: GitHub, https://github.com/django-simple-deploy/dsd-upsun
+Project-URL: Changelog, https://github.com/django-simple-deploy/dsd-upsun/blob/main/CHANGELOG.md
+Keywords: django,deployment
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: django>=4.2
+Requires-Dist: pluggy>=1.5.0
+Requires-Dist: toml>=0.10.2
+Requires-Dist: requests>=2.32.2
+Requires-Dist: django-simple-deploy>=1.3.0
+Provides-Extra: dev
+Requires-Dist: black>=24.1.0; extra == "dev"
+Requires-Dist: build>=1.2.1; extra == "dev"
+Requires-Dist: pytest>=8.3.0; extra == "dev"
+Requires-Dist: twine>=5.1.1; extra == "dev"
+Dynamic: license-file
+
+# dsd-upsun
+
+A plugin for deploying Django projects to Upsun, using django-simple-deploy.
+
+For full documentation, see the documentation for [django-simple-deploy](https://django-simple-deploy.readthedocs.io/en/latest/).

dsd_upsun-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+dsd_upsun/__init__.py,sha256=Hhn4V_hCKQV525mBTRr7oHtiSeaJOGrxuI00HABDffQ,73
+dsd_upsun/deploy.py,sha256=nsKWnh8UQH6ddlqNTI7jYU1oLyMMAaqrwCJuVbUrTeQ,557
+dsd_upsun/deploy_messages.py,sha256=Ht5-mgEM_rVmBaS6gQm6VBkXklI-Y4r4uK1lq-09xys,6839
+dsd_upsun/platform_deployer.py,sha256=aWrAuw8IFRkGCAVdvw59jmOgwtEdLuweloSI1XqWqLs,15763
+dsd_upsun/plugin_config.py,sha256=QAhymAPun38GSm7_yTKXVUf_kPJD8nt2psfMFJQuLBE,853
+dsd_upsun/utils.py,sha256=YmmjDCJ23nOI1pqqnOnm6sSJ2ejUrMgdR6o75VaDfk8,999
+dsd_upsun/templates/pipenv.platform.app.yaml,sha256=jeIR5PhPka5Y8kW3hBmJ1yp1PqNyKCBBW4mH0T8pc_k,1973
+dsd_upsun/templates/platform.app.yaml,sha256=N2mq6nlJRb7HCPO9_I4F9jcmNJNgpg5tO_5m3pS5QG4,1930
+dsd_upsun/templates/poetry.platform.app.yaml,sha256=OrU6FJa-kzwTK-VT5414X09ionkARWjIQpD0w3KKqO0,2419
+dsd_upsun/templates/services.yaml,sha256=eLN8qe9VZqMt9o9DKlA11vRGYiO1Qg1qBw-yWqaKXLA,231
+dsd_upsun/templates/settings.py,sha256=EJVGvX4wNdyhw10--vf4Z75pySLIJqHWp6lN0RQoKBA,1134
+dsd_upsun-0.1.0.dist-info/licenses/LICENSE,sha256=eE0PSpGK-C_T72lmuE6kQ_Am4fOlJympaeS_aItmiws,1484
+dsd_upsun-0.1.0.dist-info/METADATA,sha256=JWuwPCHNJaiM4JLatk461J7mWUsnpNSiZyvkxWxwg0w,1802
+dsd_upsun-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dsd_upsun-0.1.0.dist-info/top_level.txt,sha256=3WChrd4xa_Bh0gQG6SKGhSuKEfYgWRxWZrqAcdUh4W0,10
+dsd_upsun-0.1.0.dist-info/RECORD,,

dsd_upsun-0.1.0.dist-info/WHEEL

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

dsd_upsun-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) Eric Matthes and individual contributors.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

dsd_upsun-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dsd_upsun