@seniorsistemas/exclusion-process-component 0.0.1-c049d10c-e93a-4d63-9c2a-b17bca40c324 → 0.6.0-44030ff3-2eeb-49f7-8927-0920cc01a805

package/senior-ci/release-candidate/common/create_hotfix.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+get_version_release_candidate
+
+call_extension "before_release"
+
+echo -e "[CI] Iniciando processo de GitFlow\n"
+
+echo "[CI] Criando branch hotfix/$VERSION_HYPHEN"
+git checkout -B hotfix/$VERSION_HYPHEN
+
+call_extension "before_change_changelog"
+
+commit_changelog_template $VERSION
+
+call_extension "after_change_changelog"
+
+change_version
+
+git commit -a -m "[CI] Criando versão $VERSION"
+
+CI_REPOSITORY_URL_FOR_PUSH=$(echo "$CI_REPOSITORY_URL" | sed -e "s|.*@\(.*\)|git@\1|" -e "s|/|:|" )
+git remote set-url --push origin "$CI_REPOSITORY_URL_FOR_PUSH"
+
+echo "[CI] Enviando branch de hotfix"
+git push origin hotfix/$VERSION_HYPHEN
+
+exit

package/senior-ci/release-candidate/common/create_release.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+get_version_release_candidate
+
+call_extension "before_release"
+
+create_release_branch
+
+call_extension "before_change_changelog"
+
+update_changelog_version
+
+call_extension "after_change_changelog"
+
+change_version
+
+git commit -a -m "[CI] Criando versão $VERSION" -m "[auto release]"
+
+git checkout develop
+
+sed -i 's/{version}/'"$VERSION"'/' CHANGELOG.md
+
+commit_changelog_template
+
+push_branch_changes
+
+echo "[CI] Pushing branchs"
+git push --all
+
+exit

package/senior-ci/release-candidate/create_branch.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+
+usage()
+{
+	printf "\nWelcome,"
+	printf "\nThis script is used with the propouse of optimize the branch generation in your project\n"
+
+	printf "\nHow to Use:"
+	printf "\n\nA first parameter:"
+	printf "\nUse '-M' to specify that a major release will be create"
+	printf "\nUse '-m' to specify that a minor release will be create"
+	printf "\nUse '-p' to specify that a patch release will be create"
+	printf "\nUse '-h' to specify that a hotfix will be create"
+	printf "\n\nAnd a second parameter:"
+	printf "\nUse '--front' to specify that a branch are of frontend repository"
+	printf "\nUse '--back' to specify that a branch are of backend repository"
+	printf "\n"
+}
+
+invalid()
+{
+	printf "\n $1 Option or Argument is invalid.\n"
+}
+
+. senior-ci/common/senior-ci-extensions-helpers.sh
+. senior-ci/common/release-helpers.sh
+
+case $2 in
+    --back)
+        REPO=back
+        ;;
+    --front)
+        REPO=front
+        ;;
+    *)
+        invalid $2;
+        usage;
+        exit 1
+        ;;
+esac
+
+case $1 in
+    -M)
+        RELEASE_KIND=major
+        . senior-ci/release-candidate/common/create_release.sh
+        ;;
+    -m)
+        RELEASE_KIND=minor
+        . senior-ci/release-candidate/common/create_release.sh
+        ;;
+    -p)
+        RELEASE_KIND=patch
+        . senior-ci/release-candidate/common/create_release.sh
+        ;;
+    -h)
+        RELEASE_KIND=patch
+        . senior-ci/release-candidate/common/create_hotfix.sh
+        ;;
+    *)
+        invalid $1;
+        usage;
+        exit 1
+        ;;
+esac

package/senior-ci/release-candidate/frontend/get_version.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+
+change_version() {
+	npm version --no-git-tag-version "$VERSION"
+
+	sed -i '3d' package.json
+	sed -i '3s|^|\t"version": "'$VERSION'",\n|' package.json
+}
+
+HEAD="$(git show -s --pretty=%d HEAD)"
+
+echo $HEAD
+
+VERSION="$(echo "$HEAD" | cut -d ',' -f2 | sed "s/-\([[:digit:]]\)/\.\1/g" | sed "s/[^[:digit:].]//g")"
+
+echo "head version: $VERSION"
+
+if [ -z "${VERSION}" ]; then
+	PACKAGE=$(<package.json)
+	VERSION=$(echo "$PACKAGE" | grep "version\":" | head -1 | cut -d ":" -f 2 | sed "s/[{, }, \", ',[:space:]]//g";)
+fi
+
+echo "package version: $VERSION"
+
+if [ "$1" == "major" -o "$1" == "minor" -o "$1" == "patch" -o $? -ne 0 ]; then
+  get_next_version $1
+fi
+
+echo "senior-ci version: $VERSION"
+
+VERSION_HYPHEN=$(echo "v$VERSION" | sed "s/\.\([[:digit:]]\)/-\1/g")
+
+git ls-remote --heads origin | grep -E "refs/heads/hotfix/${VERSION_HYPHEN}/$" >/dev/null
+
+if [[ "$?" -eq "0" ]]; then
+    echo "[CI] Já tem um hotfix para gerar a versão $VERSION, iremos considerrar a próxima"
+
+  get_next_version $1 $VERSION
+
+	VERSION_HYPHEN = $(echo "v$VERSION" | sed "s/\.\([[:digit:]]\)/-\1/g");
+fi
+
+echo -e "[CI] Version $VERSION_HYPHEN will be created\n"

package/senior-ci/requirements-dev.txt

@@ -0,0 +1,5 @@
+-r requirements.txt
+
+black==22.1.0
+pylint==2.12.2
+python-dotenv==0.19.2

package/senior-ci/requirements.txt

@@ -0,0 +1,5 @@
+colorama==0.4.4
+gql==2.0.0
+jira==3.1.1
+PyYAML==6.0
+boto3==1.12.24

package/senior-ci/scripts/apply_yamls.py

@@ -0,0 +1,229 @@
+import json
+import sys
+import time
+from typing import NoReturn
+
+import boto3
+from colorama import Fore
+
+sys.path.append("./senior-ci")
+
+from common import (
+    ExitCode,
+    exec_command,
+    exec_command_and_return,
+    exec_command_without_print,
+    exit_message,
+    get_env_variable,
+    get_env_variable_required,
+    print_message,
+)
+
+LOCAL_PORT_NUMBER = "32221"
+SKIPPED_STATUS = "Skipped"
+DEVOPS_CD_ROOT_FOLDER = "devops_cd"
+user = get_env_variable("SCI_BASTION_USER", "ec2-user")
+instance_id = get_env_variable_required("SCI_EC2_INSTANCE_ID")
+sci_aws_account_id = get_env_variable_required("SCI_AWS_ACCOUNT_ID")
+default_region = get_env_variable_required("AWS_DEFAULT_REGION")
+keep_devops_cd_folder = get_env_variable("SCI_KEEP_DEVOPS_CD_FOLDER", "false").lower() == 'true'
+need_execute_apply_yamls = get_env_variable("SCI_EXECUTE_APPLY_YAMLS", "true").lower() == 'true'
+
+def run_ec2_command(command: str) -> NoReturn:
+    exec_command(f'ssh -p {LOCAL_PORT_NUMBER} {user}@localhost "{command}"')
+
+def create_folders(folders: list) -> NoReturn:
+    folders_str = ' '.join(folders)
+    command = f"mkdir -p {folders_str}"
+    run_ec2_command(command)
+
+def run_scp_command(files: list) -> NoReturn:
+    for filename in files:
+        path_parts = filename.split('/')
+        relative_path = '/'.join(path_parts[:-1])
+        command_string = f"scp -P {LOCAL_PORT_NUMBER} {filename}"
+        scp_command = f"{command_string} {user}@localhost:{DEVOPS_CD_ROOT_FOLDER}/{relative_path}"
+        cmd = exec_command(scp_command)
+        if cmd.exit_code != ExitCode.SUCCESS:
+            exit_message(f"Não foi possível executar o SCP para o arquivo {filename}. Exit code: {cmd.exit_code}")
+
+def access_bastion():
+    print("")
+    print_message("Acessando Bastion para aplicar os deployments.", Fore.CYAN)
+    print("")
+
+    sts = boto3.client("sts")
+    assumed_role_object = sts.assume_role(
+        RoleArn=f"arn:aws:iam::{sci_aws_account_id}:role/GitlabPipeline",
+        RoleSessionName="GitlabPipeline",
+    )
+    credentials = assumed_role_object["Credentials"]
+    ssm = boto3.client(
+        "ssm",
+        aws_access_key_id=credentials["AccessKeyId"],
+        aws_secret_access_key=credentials["SecretAccessKey"],
+        aws_session_token=credentials["SessionToken"],
+    )
+
+    print_message("Port Forwarding")
+    response = ssm.start_session(
+        Target=instance_id,
+        DocumentName="AWS-StartPortForwardingSession",
+        Parameters={
+            "portNumber": ["22"],
+            "localPortNumber": [LOCAL_PORT_NUMBER],
+        },
+    )
+    build_ssm_plugin(response)
+
+    # Tempo para iniciar o SSH Tunnel
+    time.sleep(5)
+
+    exec_command_without_print('echo "$SCI_BASTION_PRIVATE_KEY" | ssh-add -')
+
+    yamls_list = run_scp_of_yaml_diff()
+
+    if need_execute_apply_yamls:
+        comment = ','.join(yamls_list)
+        # Truncates de comment
+        comment = comment[:100]
+        status = execute_apply_yamls(ssm, comment)
+    else:
+        status = SKIPPED_STATUS
+
+    if not keep_devops_cd_folder:
+        run_ec2_command(f"sudo rm -rf {DEVOPS_CD_ROOT_FOLDER}")
+
+    check_command_invocation_status(status)
+
+def execute_apply_yamls(ssm, comment):
+    print_message("Sending SSM command to apply YAMLs...")
+    response = ssm.send_command(
+            InstanceIds=[instance_id],
+            DocumentName="DevOps-ApplyYamls",
+            Comment=comment,
+            Parameters={
+                "User": [user]
+            }
+        )
+    
+    print_message(f"SSM Command id: {response['Command']['CommandId']}")
+
+    output = None
+    command_not_finish = True
+
+    # Loop para validar se o comando já foi executado
+    while command_not_finish:
+        time.sleep(5)
+
+        output = ssm.get_command_invocation(
+                CommandId=response["Command"]["CommandId"], InstanceId=instance_id
+            )
+
+        print_message("Command current status: {}".format(output["Status"]))
+        if output["Status"] != "InProgress":
+            command_not_finish = False
+
+    stdout = output["StandardErrorContent"]
+    lines = stdout.split("\n")
+    del lines[-1]
+
+    for line in lines:
+        print_message(line)
+
+    stdout = output["StandardOutputContent"]
+    lines = stdout.split("\n")
+    del lines[-1]
+
+    for line in lines:
+        print_message(line)
+    return output["Status"]
+
+
+def run_scp_of_yaml_diff() -> list:
+    caught_yamls = exec_command_and_return("git diff HEAD^ --name-only -- '*.yaml' '*.yml'")
+    caught_yamls_output = caught_yamls.output
+    if not caught_yamls_output:
+        exit_message(
+            "Não foi possível encontrar nenhum yaml para realizar a aplicação!"
+        )
+    caught_yamls_list = caught_yamls_output.split('\n')
+
+    # Removes empty strings
+    caught_yamls_list = [ filename for filename in caught_yamls_list if filename.strip() ]
+    # Make a list with folders
+    folders_to_create = [ '/'.join(filename.split('/')[:-1]) for filename in caught_yamls_list ]
+    # Removes duplicates (set) and add root folder for devops_cd
+    folders_to_create = [ f"devops_cd/{folder}" for folder in set(folders_to_create) ]
+
+    create_folders(folders_to_create)
+    run_scp_command(caught_yamls_list)
+    run_scp_of_cd_script(caught_yamls_list)
+    return caught_yamls_list
+
+
+def run_scp_of_cd_script(caught_yamls: list) -> NoReturn:
+    caught_yamls_str = ' '.join(caught_yamls)
+    with open("k8s_apply.sh", "w", encoding="utf-8") as k8s_apply_sh:
+        script = (
+            "#!/bin/bash\n"
+            "\n"
+            "sudo wget -q https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 -O /usr/bin/yq\n"
+            "\n"
+            f"export KUBECONFIG=/home/{user}/.kube/config\n"
+            "\n"
+            f"yamls=({caught_yamls_str})\n"
+            "\n"
+            "for i in ${yamls[@]}; do\n"
+            '    if [ -f "$i" ]; then\n'
+            "        kubectl apply -f $i\n"
+            "\n"
+            "        name=`cat $i | /usr/bin/yq -r .metadata.name`\n"
+            "        namespace=`cat $i | /usr/bin/yq -r .metadata.namespace`\n"
+            "\n"
+            "        if ! kubectl rollout status deployment $name -n $namespace; then\n"
+            "            kubectl rollout undo deployment $name -n $namespace\n"
+            "            kubectl rollout status deployment $name -n $namespace\n"
+            "        fi\n"
+            "    else\n"
+            '        echo "Arquivo não encontrado - $i"\n'
+            "    fi\n"
+            "done\n"
+            "\n"
+            "echo 'Finish'\n"
+        )
+        k8s_apply_sh.write(script)
+
+    run_scp_command(["k8s_apply.sh"])
+
+def check_command_invocation_status(status: str) -> NoReturn:
+    if status == "Success":
+        print_message("Deploy realizado com sucesso na Bastion!", Fore.GREEN)
+    elif status == SKIPPED_STATUS:
+        print_message("A etapa de deploy foi ignorada.", Fore.YELLOW)
+    else:
+        exit_message(
+            "Não foi possível realizar o deploy, pois foi finalizado com erro."
+        )
+
+
+def build_ssm_plugin(session_manager_response) -> NoReturn:
+    plugin_file = "session-manager-plugin.deb"
+    session_manager_url = (
+        "https://s3.amazonaws.com/session-manager-downloads/"
+        f"plugin/latest/ubuntu_64bit/{plugin_file}"
+    )
+    exec_command(f'curl -s {session_manager_url} -o "{plugin_file}"')
+    exec_command(f"sudo dpkg -i {plugin_file}")
+
+    dumped_res = json.dumps(session_manager_response)
+    dumped_trgt = json.dumps(dict(Target=instance_id))
+    ssm_aws_url = f"https://ssm.{default_region}.amazonaws.com"
+    ssm_prefix = "session-manager-plugin"
+    session_start = f"{ssm_prefix} '{dumped_res}' {default_region} StartSession default '{dumped_trgt}' {ssm_aws_url}"
+
+    exec_command_without_print(f"{session_start} > /dev/null 2>&1 &")
+    exec_command_without_print(f"rm session-manager-plugin.deb")
+
+
+access_bastion()

package/senior-ci/scripts/create_sre_issue/__main__.py

@@ -0,0 +1,7 @@
+import sys
+
+sys.path.append("./senior-ci")
+
+from create_sre_issue import CreateSreIssue
+
+CreateSreIssue(sys.argv[1:]).exec()

package/senior-ci/scripts/create_sre_issue/create_sre_issue.py

@@ -0,0 +1,267 @@
+import json
+import os
+from datetime import datetime
+from string import capwords
+
+from colorama import Fore
+from helpers import Backend, ChangelogReader, Frontend, Repository, find_changed_files
+from jira_manager import JiraManager
+
+from common import (
+    exit_message,
+    get_commit_tag_as_semver,
+    get_env_variable,
+    get_env_variable_required,
+    is_frontend,
+    print_message,
+)
+from common.getopt_helper import GetOptBuilder, Param
+from common.graphql_client import GraphqlClient
+
+
+class CreateSreIssue(GetOptBuilder):
+    def __init__(self, argv):
+        builder = super()
+        builder.__init__(argv)
+        self.client_graphql = GraphqlClient()
+
+        # Deprecated
+        tag_param = Param(
+            "tag", default_value=get_env_variable_required("CI_COMMIT_TAG")
+        )
+
+        # Deprecated (Only backend remuneration projects use)
+        repository_param = Param(
+            "repository", default_value=get_env_variable_required("CI_PROJECT_NAME")
+        )
+
+        module_param = Param("module", default_value="")
+
+        # Deprecated
+        changelog_base_path_param = Param("changelog_base_path", default_value=".")
+
+        sre_team_param = Param("sre_team", is_required=True)
+        translations_path_param = Param("translations_path", only_verbose=True)
+
+        builder.add_params(
+            [
+                tag_param,
+                repository_param,
+                module_param,
+                changelog_base_path_param,
+                sre_team_param,
+                translations_path_param,
+            ]
+        )
+
+        builder.build()
+
+        self.tag = tag_param.get_param_value()
+        self.module = module_param.get_param_value()
+        self.changelog_base_path = changelog_base_path_param.get_param_value()
+        self.sre_team = sre_team_param.get_param_value()
+        self.translations_path = translations_path_param.get_param_value()
+
+        self.jira_manager = JiraManager()
+
+        self.tag_semver = get_commit_tag_as_semver()
+
+        self.changelog_reader = ChangelogReader(
+            self.changelog_base_path, self.jira_manager
+        )
+
+        repository_name = repository_param.get_param_value()
+
+        self.repository: Repository = (
+            Frontend(self.tag_semver, repository_name)
+            if is_frontend()
+            else Backend(self.tag_semver, repository_name)
+        )
+
+    def exec(self):
+        """Reads the issues from a given version in changelog and creates an 'deploy issue'"""
+
+        changelog_issues = self.changelog_reader.read_issues()
+
+        if not changelog_issues:
+            exit_message(
+                f"Nenhuma task encontrada no CHANGELOG para a tag {self.tag_semver}",
+            )
+
+        sre_issue_type = (
+            "Bug"
+            if any(issue.fields.issuetype.name == "Bug" for issue in changelog_issues)
+            else "Story"
+        )
+
+        sre_issue = self._create_sre_issue(sre_issue_type)
+
+        success_message = (
+            "Task criada para o SRE: "
+            f"{self.jira_manager.get_issue_url(sre_issue.key)} - {sre_issue.fields.summary} ({self.tag_semver})"
+        )
+
+        print_message(success_message, Fore.GREEN)
+
+        for issue in changelog_issues:
+            if self.jira_manager.create_link(
+                "Dependência entre atividades", issue, sre_issue
+            ):
+                print_message(
+                    f"Link criado: {self.jira_manager.get_issue_url(issue.key)} - {sre_issue.key}",
+                    Fore.GREEN,
+                )
+
+    def _create_sre_issue(self, sre_issue_type):
+        jira_issue = {
+            "project": {"key": self.sre_team},
+            "summary": f"Deploy {self.repository.deployment}",
+            "issuetype": {"name": "Deploy"},
+            "labels": [sre_issue_type, self.module],
+            "description": self.get_description(),
+            self.repository.deploy_name_custom_field: [self.repository.deploy_info],
+            "customfield_11100": [{"value": "Produção - platform.senior.com.br"}],
+        }
+
+        return self.jira_manager.create_issue(jira_issue)
+
+    def get_description(self):
+        description = "*Changelog*\n"
+        description += self.changelog_reader.changelog_url
+        description += "\n\n"
+
+        translations_path = (
+            self.translations_path
+            if self.translations_path
+            else self.repository.translations_path
+        )
+        changed_files = find_changed_files(translations_path)
+        translations = ""
+        project_url = get_env_variable_required("CI_PROJECT_URL")
+
+        for translation_file in changed_files:
+            filename = os.path.basename(translation_file)
+            if filename:
+                translations += (
+                    f"[{filename}|{project_url}/-/raw/{self.tag}/{translation_file}]\n"
+                )
+
+        if translations:
+            description += (
+                f"*Favor atualizar os arquivos de tradução:*\n{translations}\n\n"
+            )
+
+        description += self.create_merge_request_table()
+
+        description += f"\n[Deploy pelo SRE Platform|{self.create_sre_platform_url()}]"
+
+        return description
+
+    def create_merge_request_table(self):
+        table_head = (
+            "h2.Merge Requests\n||Título|||Validação do review|||Aberto por|||Fechado por"
+            "|||Pipeline|||Aberto em|||Fechado em||\n"
+        )
+        table_data = table_head
+        merge_requests = self.get_merges_between_tags()
+
+        for merge_request in merge_requests:
+            title = merge_request["title"].replace("[", "").replace("]", "")
+            author = capwords(merge_request["author"].replace(".", " "))
+            merged_by = capwords(merge_request["mergedBy"].replace(".", " "))
+
+            mr_title = f"*[{title}|{merge_request['url']}]*"
+            author_name = (
+                f"[{author}|https://git.senior.com.br/{merge_request['author']}]"
+            )
+            closed_by_name = (
+                f"[{merged_by}|https://git.senior.com.br/{merge_request['mergedBy']}]"
+            )
+            pipeline_status = (
+                "(/)" if merge_request["pipelineStatus"] == "success" else "(x)"
+            )
+            review = "(/)"
+
+            if merge_request["author"] == merge_request["mergedBy"]:
+                author_name += " (flag)"
+                closed_by_name += " (flag)"
+                review = "(x)"
+
+            table_row = (
+                f"|{mr_title}||{review}|{author_name}|{closed_by_name}|"
+                f"|{pipeline_status}|{merge_request['createdAt']}|{merge_request['mergedAt']}|\n"
+            )
+            table_data += table_row
+
+        table_subtitle = "~O ícone (flag) indica se o Merge Request foi aberto e fechado pela mesma pessoa.~\n"
+        table_data += table_subtitle
+
+        return table_data
+
+    def get_merges_between_tags(self):
+        query = """
+            query ($projectId: Int!, $referenceTag: String) {
+                mergesBetweenTags(projectId: $projectId, referenceTag: $referenceTag) {
+                    mergeRequestsData {
+                    url
+                    title
+                    createdAt
+                    mergedAt
+                    pipelineStatus
+                    author
+                    assignee
+                    reviewer
+                    mergedBy
+                    }
+                }
+            }
+        """
+
+        params = {
+            "projectId": int(get_env_variable_required("CI_PROJECT_ID")),
+            "referenceTag": self.repository.version,
+        }
+
+        request = self.client_graphql.call(query, params)
+
+        merge_requests_data = request["mergesBetweenTags"]["mergeRequestsData"]
+
+        for merge_request_data in merge_requests_data:
+            merge_request_data["createdAt"] = datetime.strftime(
+                datetime.fromisoformat(merge_request_data["createdAt"]),
+                "%d/%m/%y %H:%M",
+            )
+            merge_request_data["mergedAt"] = datetime.strftime(
+                datetime.fromisoformat(merge_request_data["mergedAt"]), "%d/%m/%y %H:%M"
+            )
+
+        return merge_requests_data
+
+    def create_sre_platform_url(self):
+        sci_project_type = get_env_variable_required("SCI_PROJECT_TYPE")
+
+        if sci_project_type in [
+            "ANGULAR_SENIORX",
+            "ANGULAR_GENERATED",
+        ]:
+            package_json_file = open("package.json", "r", encoding="utf-8")
+            package_json = json.load(package_json_file)
+
+            name = package_json["project"]["app"]
+            domain = package_json["project"]["domain"]
+            service = package_json["project"]["service"]
+            version = get_env_variable_required("CI_COMMIT_TAG").replace("-", ".")
+
+            query_params = f"name={name}"
+            query_params += f"&domain={domain}"
+            query_params += f"&service={service}"
+            query_params += f"&version={version}"
+            query_params += "&type=FRONTEND"
+
+        else:
+            query_params = f"name={self.repository.deployment}"
+            query_params += f"&version={self.repository.version}"
+            query_params += f"&sreJiraKey={self.sre_team}"
+            query_params += "&type=BACKEND"
+
+        return f"https://sre-platform.senior.com.br/deployment?{query_params}"