suite-py 1.41.10__py3-none-any.whl → 1.42.1__py3-none-any.whl

suite_py/commands/deploy.py

@@ -1,207 +0,0 @@
-# -*- coding: utf-8 -*-
-import re
-import sys
-
-from suite_py.commands import common
-from suite_py.commands.release import _parse_available_countries
-from suite_py.lib import logger, metrics
-from suite_py.lib.handler import git_handler as git
-from suite_py.lib.handler import prompt_utils
-from suite_py.lib.handler.changelog_handler import ChangelogHandler
-from suite_py.lib.handler.drone_handler import DroneHandler
-from suite_py.lib.handler.git_handler import GitHandler
-from suite_py.lib.handler.github_handler import GithubHandler
-from suite_py.lib.handler.version_handler import DEFAULT_VERSION, VersionHandler
-from suite_py.lib.handler.youtrack_handler import YoutrackHandler
-
-
-class Deploy:
-    # pylint: disable=too-many-instance-attributes
-    def __init__(self, project, captainhook, config, tokens):
-        self._project = project
-        self._config = config
-        self._youtrack = YoutrackHandler(config, tokens)
-        self._captainhook = captainhook
-        self._changelog_handler = ChangelogHandler()
-        self._github = GithubHandler(tokens)
-        self._repo = self._github.get_repo(project)
-        self._git = GitHandler(project, config)
-        self._drone = DroneHandler(config, tokens, repo=project)
-        self._countries = _parse_available_countries(self._drone)
-        self._version = VersionHandler(self._repo, self._git, self._github)
-
-    @metrics.command("deploy")
-    def run(self):
-        self._stop_if_prod_locked()
-
-        self._git.fetch()
-
-        if len(self._countries) > 0:
-            logger.error(
-                "Deploy command cannot be used on this project. Try to run `suite-py release` instead."
-            )
-            sys.exit(1)
-
-        current_version = self._version.get_latest_version()
-
-        if current_version != "":
-            logger.info(f"The current release is {current_version}")
-            commits = self._github.get_commits_since_release(
-                self._repo, current_version
-            )
-
-            _check_migrations_deploy(commits)
-
-            message = "\n".join(
-                [
-                    "* "
-                    + c.commit.message.splitlines()[0]
-                    + " by "
-                    + c.commit.author.name
-                    for c in commits
-                ]
-            )
-
-            logger.info(f"\nCommits list:\n{message}\n")
-
-            if not prompt_utils.ask_confirm("Do you want to continue?"):
-                sys.exit()
-
-            new_version = self._version.select_new_version(
-                current_version, allow_prerelease=True, allow_custom_version=True
-            )
-
-        else:
-            # Se non viene trovata la release e non ci sono tag, viene saltato il check delle migrations e l'update delle card su youtrack
-            logger.warning(
-                f"No tags found, I'm about to push the tag {DEFAULT_VERSION}"
-            )
-            if not prompt_utils.ask_confirm(
-                "Are you sure you want to continue?", default=False
-            ):
-                sys.exit()
-            new_version = DEFAULT_VERSION
-            message = f"First release with tag {new_version}"
-
-        if self._changelog_handler.changelog_exists():
-            (
-                latest_tag,
-                latest_entry,
-            ) = self._changelog_handler.get_latest_entry_with_tag()
-
-            if latest_tag != new_version:
-                if not prompt_utils.ask_confirm(
-                    "You didn't update your changelog, are you sure you want to proceed?"
-                ):
-                    sys.exit()
-            else:
-                message = f"{latest_entry}\n\n# Commits\n\n{message}"
-
-        message = common.ask_for_release_description(message)
-
-        self._create_release(new_version, message)
-        self._manage_youtrack_card(commits, new_version)
-
-    def _stop_if_prod_locked(self):
-        request = self._captainhook.status(self._project, "production")
-        if request.status_code != 200:
-            logger.error("Unable to determine lock status on master.")
-            sys.exit(-1)
-
-        request_object = request.json()
-        if request_object["locked"]:
-            logger.error(
-                f"The project is locked in production by {request_object['by']}. Unable to continue."
-            )
-            sys.exit(-1)
-
-    def _create_release(self, new_version, message):
-        new_release = self._repo.create_git_release(
-            new_version,
-            new_version,
-            self._youtrack.replace_card_names_with_md_links(message),
-        )
-        if new_release:
-            logger.info(f"The release has been created! Link: {new_release.html_url}")
-
-            build_number = self._drone.get_build_number_from_tag(new_version)
-            if build_number:
-                drone_url = self._drone.get_build_url(build_number)
-                logger.info(
-                    f"You can follow the deployment in production here: {drone_url}"
-                )
-
-    def _manage_youtrack_card(self, commits, new_version):
-        release_state = self._config.youtrack["release_state"]
-
-        issue_ids = self._youtrack.get_issue_ids(commits)
-
-        if len(issue_ids) > 0:
-            update_youtrack_state = prompt_utils.ask_confirm(
-                f"Do you want to move the associated cards to {release_state} state?",
-                default=False,
-            )
-
-            for issue_id in issue_ids:
-                try:
-                    self._youtrack.comment(
-                        issue_id,
-                        f"Deploy in production of {self._project} done with the release {new_version}",
-                    )
-                    if update_youtrack_state:
-                        self._youtrack.update_state(issue_id, release_state)
-                        logger.info(f"{issue_id} moved to {release_state}")
-                except Exception:
-                    logger.warning(
-                        f"An error occurred while moving the card {issue_id} to {release_state}"
-                    )
-                repos_status = self._get_repos_status_from_issue(issue_id)
-                if all(r["deployed"] for r in repos_status.values()):
-                    try:
-                        self._youtrack.update_deployed_field(issue_id)
-                        logger.info("Custom field Deployed updated on YouTrack")
-                    except Exception:
-                        logger.warning(
-                            "An error occurred while updating the custom field Deployed"
-                        )
-
-    def _get_repos_status_from_issue(self, issue_id):
-        regex_pr = r"^PR .* -> https:\/\/github\.com\/primait\/(.*)\/pull\/([0-9]*)$"
-        regex_deploy = r"^Deploy in production of (.*) done with the release"
-        comments = self._youtrack.get_comments(issue_id)
-        repos_status = {}
-
-        for c in comments:
-            m = re.match(regex_pr, c["text"])
-            if m:
-                project = m.group(1)
-                pr_number = int(m.group(2))
-                repos_status[project] = {}
-                repos_status[project]["pr"] = pr_number
-                repos_status[project]["deployed"] = False
-            m = re.match(regex_deploy, c["text"])
-            if m:
-                project = m.group(1)
-                try:
-                    repos_status[project]["deployed"] = True
-                except Exception:
-                    pass
-        return repos_status
-
-
-def _check_migrations_deploy(commits):
-    if not commits:
-        logger.error("ERROR: no commit found")
-        sys.exit(-1)
-    elif len(commits) == 1:
-        files_changed = git.files_changed_between_commits("--raw", f"{commits[0].sha}~")
-    else:
-        files_changed = git.files_changed_between_commits(
-            f"{commits[-1].sha}~", commits[0].sha
-        )
-    if git.migrations_found(files_changed):
-        logger.warning("WARNING: migrations detected in the code")
-        if not prompt_utils.ask_confirm(
-            "Are you sure you want to continue?", default=False
-        ):
-            sys.exit()

suite_py/commands/docker.py

@@ -1,91 +0,0 @@
-# -*- coding: utf-8 -*-
-import sys
-
-from halo import Halo
-
-from suite_py.lib import logger, metrics
-from suite_py.lib.handler import prompt_utils
-from suite_py.lib.handler.drone_handler import DroneHandler
-from suite_py.lib.handler.git_handler import GitHandler
-from suite_py.lib.handler.github_handler import GithubHandler
-
-
-class Docker:
-    # pylint: disable=too-many-instance-attributes
-    def __init__(self, action, project, config, tokens, flags=None):
-        self._action = action
-        self._project = project
-        self._flags = flags
-        self._config = config
-        self._tokens = tokens
-        self._github = GithubHandler(tokens)
-        self._repo = self._github.get_repo(project)
-        self._git = GitHandler(project, config)
-        self._drone = DroneHandler(config, tokens, repo=project)
-
-    @metrics.command("docker")
-    def run(self):
-        if self._project != "docker":
-            logger.error("`suite-py docker` must run inside docker repository.")
-            sys.exit(-1)
-
-        self._git.fetch()
-
-        pipelines = self._drone.parse_yaml()
-
-        if pipelines is None:
-            logger.error("The file .drone.yml not found.")
-            sys.exit(1)
-
-        images = []
-        for pipeline in pipelines:
-            if "trigger" not in pipeline or "ref" not in pipeline["trigger"]:
-                continue
-
-            trigger_tags = pipeline["trigger"]["ref"]
-
-            for tag in trigger_tags:
-                images.append(tag.replace("refs/tags/", ""))
-
-        image = prompt_utils.ask_choices(
-            "Select an image",
-            images,
-        )
-        versions = self._get_versions(image)
-
-        if self._action == "release":
-            print_versions(versions)
-            new_version = self._ask_new_version(image)
-            self._create_new_version(new_version)
-
-        elif self._action == "versions":
-            print_versions(versions)
-
-    def _create_new_version(self, version):
-        if prompt_utils.ask_confirm(f"Tag {version} will be deployed. Confirm?"):
-            self._git.tag(version, version)
-            self._git.push(version)
-
-    def _ask_new_version(self, image):
-        new = prompt_utils.ask_questions_input(
-            "Write new version to be deployed (eg: 11.3-1):"
-        )
-        if new[0] == "v":
-            logger.error("Insert new version without `v`")
-            sys.exit(-1)
-        return f'{image.replace("*", "")}{new}'
-
-    def _get_versions(self, image):
-        versions = []
-        with Halo(text="Retrieving tags...", spinner="dots", color="magenta"):
-            tags = self._github.get_tags("docker")
-            for tag in tags:
-                if image.replace("*", "") in tag.name:
-                    versions.append(tag)
-            return versions
-
-
-def print_versions(versions):
-    message = "\n".join(["* " + v.name for v in versions])
-
-    logger.info(f"\nVersions list:\n{message}\n")

suite_py/commands/generator.py

@@ -1,238 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-import stat
-import subprocess
-from datetime import datetime
-from os import listdir
-from os.path import isfile, join
-
-import yaml
-from jinja2 import DebugUndefined, Environment, FileSystemLoader
-
-from suite_py.lib import logger, metrics
-from suite_py.lib.handler import prompt_utils
-from suite_py.lib.handler.drone_handler import DroneHandler
-from suite_py.lib.handler.git_handler import GitHandler
-from suite_py.lib.handler.github_handler import GithubHandler
-
-NOW = datetime.now().strftime("%Y%m%d%H%M")
-
-
-class Generator:
-    def __init__(self, project, config, tokens):
-        self._project = project
-        self._config = config
-        self._tokens = tokens
-        self._umami_path = os.path.join(config.user["projects_home"], "umami")
-        self._drone_values_path = f"{self._umami_path}/templates/drone/values/"
-        self._deploy_scripts_values_path = (
-            f"{self._umami_path}/templates/scripts/values/"
-        )
-        self._github = GithubHandler(tokens)
-
-    @metrics.command("generator")
-    def run(self):
-
-        logger.warning(
-            "This command requires shellcheck and shfmt, please install these tools before continuing"
-        )
-        logger.warning(
-            "see https://github.com/koalaman/shellcheck#installing and https://github.com/mvdan/sh#shfmt for installation"
-        )
-        # move to umami root directory
-        os.chdir(self._umami_path)
-
-        env = Environment(
-            loader=FileSystemLoader(self._umami_path),
-            undefined=DebugUndefined,
-            trim_blocks=True,
-            lstrip_blocks=True,
-        )
-        env.filters["to_yaml"] = to_yaml
-        env.add_extension("jinja2.ext.do")
-
-        template_type = prompt_utils.ask_choices(
-            "What files do you want to generate?", ["drone", "deploy_scripts"]
-        )
-        commit_message = f"Autogenerated update {template_type} from suite-py {NOW}"
-
-        autobranch = prompt_utils.ask_confirm(
-            "Do you want to create branch and PR automatically?", default=False
-        )
-
-        if autobranch:
-            autopush = True
-        else:
-            autopush = prompt_utils.ask_confirm(
-                "Do you want to push automatically?", default=False
-            )
-
-        choice = prompt_utils.ask_questions_input(
-            "What project do you want to work on? Enter `all` to select them all: ",
-            self._project,
-        )
-
-        if choice == "all":
-            projects = self._get_all_templated_projects(template_type)
-        else:
-            projects = choice.split(" ")
-
-        skipped = []
-        for project in projects:
-            logger.info(f"{project}: Checking if there are no uncommitted files")
-            git = GitHandler(project, self._config)
-            git.check_repo_cloned()
-            if git.is_dirty():
-                if not prompt_utils.ask_confirm(
-                    f"{project}: There are changes already present, do you want to continue anyway?",
-                    default=False,
-                ):
-                    logger.error(f"{project}: skipping the project")
-                    skipped.append(project)
-                    continue
-
-            branch_name = _configure_branch(git, template_type, autobranch, autopush)
-
-            logger.info(f"{project}: Creation in progress")
-            # launch generate
-            if template_type == "drone":
-                self._generate_drone(
-                    project, f"{self._drone_values_path}{project}.yml", env
-                )
-            elif template_type == "deploy_scripts":
-                _generate_build_script(
-                    git.get_path(),
-                    f"{self._deploy_scripts_values_path}{project}.yml",
-                    env,
-                )
-                _generate_deploy_script(
-                    git.get_path(),
-                    f"{self._deploy_scripts_values_path}{project}.yml",
-                    env,
-                )
-            logger.info(f"{project}: Creation completed")
-
-            if autobranch or autopush:
-                # controllo che sia cambiato effettivamente qualcosa
-                if git.is_dirty(untracked=True):
-                    self._git_operations(
-                        git, autobranch, autopush, branch_name, commit_message
-                    )
-                else:
-                    logger.warning(
-                        f"{project}: no git operations to do. No files modified"
-                    )
-
-            logger.warning(f"Skipped projects: {skipped}")
-
-    def _get_all_templated_projects(self, template_type):
-        if template_type == "drone":
-            values_path = self._drone_values_path
-        elif template_type == "deploy_scripts":
-            values_path = self._deploy_scripts_values_path
-
-        return [
-            f.replace(".yml", "")
-            for f in listdir(values_path)
-            if isfile(join(values_path, f))
-        ]
-
-    def _git_operations(self, git, autobranch, autopush, branch_name, message):
-        if autobranch:
-            logger.info(f"{git.get_repo()}: creating branch {branch_name}")
-            git.checkout(branch_name, new=True)
-            git.add()
-            git.commit(message)
-            git.push(branch_name)
-            pr = self._github.create_pr(git.get_repo(), branch_name, message)
-            logger.info(f"Pull request with number {pr.number} created! {pr.html_url}")
-        elif autopush:
-            if git.current_branch_name() != "master":
-                git.add()
-                git.commit(message)
-                git.push(branch_name)
-            else:
-                logger.warning(
-                    f"{git.get_repo()} is on master, skipping automatic push"
-                )
-
-    def _generate_drone(self, project, values_file, env):
-        values = yaml.safe_load(open(values_file, encoding="utf-8"))
-        template = env.get_template(f"templates/drone/{values['template']}.j2")
-        rendered = template.render(values)
-
-        _write_on_repo(
-            os.path.join(self._config.user["projects_home"], project),
-            rendered,
-            ".drone.yml",
-        )
-        drone = DroneHandler(self._config, self._tokens, repo=project)
-        drone.fmt()
-        drone.validate()
-        drone.sign()
-
-
-def _configure_branch(git, template_type, autobranch, autopush):
-    logger.info(f"{git.get_repo()}: Synchronizing the repo with the remote")
-    if autobranch:
-        git.sync()  # fa anche checkout su master
-        return f"t/autogenerated_update_{template_type}_{NOW}"
-
-    current_branch = git.current_branch_name()
-    if autopush and git.remote_branch_exists(current_branch):
-        git.fetch()
-        git.pull()
-
-    return current_branch
-
-
-def _generate_build_script(project_path, values_file, env):
-    file_name = "build"
-    values = yaml.safe_load(open(values_file, encoding="utf-8"))
-
-    val = {**values["info"], **values["build"]}
-    template = env.get_template(f"templates/scripts/build/{val['template']}")
-    rendered = template.render(val)
-
-    _write_on_repo(os.path.join(project_path, "deploy"), rendered, file_name)
-    _format_script(f"{project_path}/deploy/{file_name}")
-    _validate_script(f"{project_path}/deploy/{file_name}")
-
-
-def _generate_deploy_script(project_path, values_file, env):
-    values = yaml.safe_load(open(values_file, encoding="utf-8"))
-
-    for country, country_props in values["deploy"].items():
-        val = {**values["info"], **country_props}
-        template = env.get_template("templates/scripts/deploy/base.j2")
-        rendered = template.render(val)
-        file_name = f"deploy-{country}"
-        _write_on_repo(os.path.join(project_path, "deploy"), rendered, file_name)
-        _format_script(f"{project_path}/deploy/{file_name}")
-        _validate_script(f"{project_path}/deploy/{file_name}")
-
-
-def _write_on_repo(path, rendered, file_name):
-    if not os.path.exists(path):
-        os.mkdir(path, mode=0o755)
-
-    with open(os.path.join(path, file_name), "w", encoding="utf-8") as fd:
-        fd.write(rendered)
-
-
-def _format_script(filepath):
-    subprocess.run(["shfmt", "-i", "2", "-l", "-w", filepath], check=True)
-
-
-def _validate_script(filepath):
-    _make_executable(filepath)
-    subprocess.run(["shellcheck", filepath], check=True)
-
-
-def _make_executable(filepath):
-    st = os.stat(filepath)
-    os.chmod(filepath, st.st_mode | stat.S_IEXEC)
-
-
-def to_yaml(d, indent=10):
-    return yaml.dump(d, indent=indent)

suite_py/commands/id.py

@@ -1,60 +0,0 @@
-# -*- coding: utf-8 -*-
-import re
-
-from pptree import Node, print_tree
-
-from suite_py.lib import logger, metrics
-from suite_py.lib.handler.aws_handler import Aws
-
-
-class ID:
-    def __init__(self, project, config, env):
-        self._project = project
-        self._env = env
-        self._aws = Aws(config)
-
-    @metrics.command("id")
-    def run(self):
-
-        clusters_names = self._aws.get_ecs_clusters(self._env)
-        n_services = Node("services")
-
-        projects = {"prima": ["web", "consumer-api"], "ab_normal": ["abnormal"]}
-        project_names = projects.get(self._project, [self._project])
-
-        for cluster_name in clusters_names:
-
-            services = []
-            all_services = self._aws.get_ecs_services(cluster_name)
-
-            for service in all_services:
-                if service["status"] == "ACTIVE":
-                    for prj in project_names:
-                        if prj in service["serviceName"]:
-                            services.append(service["serviceName"])
-
-            for service in services:
-                container_instances = []
-                container_instances = (
-                    self._aws.get_container_instances_arn_from_service(
-                        cluster_name, service
-                    )
-                )
-                if container_instances:
-                    ids = self._aws.get_ids_from_container_instances(
-                        cluster_name, container_instances
-                    )
-
-                    m = re.search(f"ecs-task-.*-{self._env}-ECSService(.*)-.*", service)
-                    if m:
-                        n_service = Node(m.group(1), n_services)
-                        for _id in ids:
-                            Node(_id, n_service)
-
-        if n_services.children:
-            print_tree(n_services, horizontal=True)
-        else:
-            logger.info(
-                f"No active tasks for {self._project} in environment {self._env}"
-            )
-        logger.info("Done!")

suite_py/commands/ip.py

@@ -1,68 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-import re
-
-from pptree import Node, print_tree
-
-from suite_py.lib import logger, metrics
-from suite_py.lib.handler.aws_handler import Aws
-
-
-class IP:
-    def __init__(self, project, config, env):
-        self._project = project
-        self._env = env
-        self._aws = Aws(config)
-
-    @metrics.command("ip")
-    def run(self):
-
-        clusters_names = self._aws.get_ecs_clusters(self._env)
-        n_services = Node("services")
-
-        projects = {"prima": ["web", "consumer-api"], "ab_normal": ["abnormal"]}
-        project_names = projects.get(self._project, [self._project])
-
-        for cluster_name in clusters_names:
-
-            services = []
-            all_services = self._aws.get_ecs_services(cluster_name)
-
-            for service in all_services:
-                if service["status"] == "ACTIVE":
-                    for prj in project_names:
-                        if prj in service["serviceName"]:
-                            services.append(service["serviceName"])
-
-            for service in services:
-                container_instances = []
-                container_instances = (
-                    self._aws.get_container_instances_arn_from_service(
-                        cluster_name, service
-                    )
-                )
-                if container_instances:
-                    ips = self._aws.get_ips_from_container_instances(
-                        cluster_name, container_instances
-                    )
-
-                    m = re.search(f"ecs-task-.*-{self._env}-ECSService(.*)-.*", service)
-                    if m:
-                        n_service = Node(m.group(1), n_services)
-                        for ip in ips:
-                            Node(ip, n_service)
-
-        if self._env == "staging" and os.path.isfile("./deploy/values/staging.yml"):
-            logger.info(
-                "This project has been migrated on k8s, command is no longer available."
-            )
-            logger.info(
-                "Please use k8s to open a shell to a staging pod, see: https://www.notion.so/K8s-tips-2f8b3fed72334362af0de0298845756d"
-            )
-        elif n_services.children:
-            print_tree(n_services, horizontal=True)
-        else:
-            logger.info(
-                f"No active tasks for {self._project} in environment {self._env}"
-            )
-        logger.info("Done!")