SonarQube: про объемы, ветки, покрытие кода и интеграцию с Gitlab

    --- приблизительный вес каждого проекта по самым большим таблицам
    select 
    tbl.project_uuid,
    pj.name, 
    pb.kee,
    sum(size_of_rows) as approximate_size_of_largest_tables 
    from (
        -- вес каждого проекта file_sources (точно)
        select 
        project_uuid,        
        sum (
            length(uuid)
            + length(project_uuid)
            + length(file_uuid)
            + length(line_hashes)
            + 4 -- line_hashes_version
            + length(data_hash)
            + length(src_hash)
            + length(revision)
            + 4 -- line_count
            + 8 -- created_at
            + 8 -- updated_at
            + length(binary_data)
            )
            as size_of_rows
        from file_sources fs2
        group by project_uuid 
        union all
        -- вес каждого проекта live_measures (не точно, большая погрешность)
        select 
        project_uuid,
        sum (
            length(uuid)
            + length(project_uuid)
            + length(component_uuid)
            + coalesce(length(metric_uuid), 1)
            + 38 -- value
            + coalesce(length(text_value), 1)
            + 38 -- variation
            + coalesce(length(measure_data), 1)
            + coalesce(length(update_marker), 1)
            + 8 -- created_at
            + 8 -- updated_at
            )
            as size_of_rows
        from live_measures
        group by project_uuid
        union all
        -- вес каждого проекта issue_changes (не точно, большая погрешность)
        select 
        project_uuid,
        sum (
            length(uuid)
            + coalesce(length(kee), 1)
            + coalesce(length(issue_key), 1)
            + coalesce(length(user_login), 1)
            + coalesce(length(change_type), 1)
            + coalesce(length(change_data), 1)
            + 8 -- created_at
            + 8 -- updated_at
            + 8 -- issue_change_creation_date
            + coalesce(length(project_uuid), 1)
            )
            as size_of_rows
        from issue_changes
        group by project_uuid
        union all
        -- вес каждого проекта issues (не точно, большая погрешность)
        select 
        project_uuid,
        sum (
            length(kee)
            + length(rule_uuid)
            + length(severity)
            + 1 -- manual_severity
            + length(message)
            + 4 -- line
            + 30 -- gap
            + length(status)
            + coalesce(length(resolution), 4)
            + coalesce(length(checksum), 4)
            + coalesce(length(assignee), 4)
            + coalesce(length(author_login), 4)
            + 4 -- effort
            + 8 -- created_at
            + 8 -- updated_at
            + 8 -- issue_creation_date
            + 8 -- issue_update_date
            + 8 -- issue_close_date
            + coalesce(length(tags), 4)
            + coalesce(length(component_uuid), 4)
            + length(project_uuid)
            + coalesce(length(locations), 4)
            + 2 -- issue_type
            + 1 -- from_hotspot
            + 1 -- quick_fix_available
            + coalesce(length(rule_description_context_key), 4)
            )
            as size_of_rows
        from issues
        group by project_uuid
    ) as tbl
    left join project_branches pb on pb.uuid = tbl.project_uuid
    left join projects pj on pj.uuid = pb.project_uuid
    group by tbl.project_uuid,
            pj.name, 
        pb.kee
    order by approximate_size_of_largest_tables desc

 ----------------------------------------------------
-- размеры всех таблиц базы (байты) со среднем количеством на одну строку 
WITH tbl AS
  (SELECT table_schema,
          TABLE_NAME
   FROM information_schema.tables
   WHERE TABLE_NAME not like 'pg_%'
     AND table_schema in ('public'))
SELECT 
       TABLE_NAME,
       rows_n,
       pg_table_size,
       pg_total_relation_size,
       pg_indexes_size,
       case 
           when rows_n = 0 then    pg_total_relation_size
              else    pg_total_relation_size/(rows_n)
       end onerow_total_size_avg
FROM (select table_schema,
          TABLE_NAME,
        (xpath('/row/c/text()', query_to_xml(format('select count(*) as c from %I.%I', table_schema, TABLE_NAME), FALSE, TRUE, '')))[1]::text::int AS rows_n,
           pg_table_size(quote_ident(table_name)) as pg_table_size,
           pg_indexes_size(quote_ident(table_name)) as pg_indexes_size,
           pg_total_relation_size(quote_ident(table_name)) as pg_total_relation_size
 from tbl) as dd
ORDER BY pg_total_relation_size DESC;

 ----------------------------------------------------
-- количество строк по таблице live_measures
select rows, LM.project_uuid, pj.name, pb.kee from  
(
select count(*) as rows, project_uuid 
from live_measures
group by project_uuid
) as LM
left join project_branches pb on pb.uuid = LM.project_uuid
left join projects pj on pj.uuid = pb.project_uuid

stages:
  - checkcode

variables:
  SONAR_ARGUMENTS: 
    -Dsonar.qualitygate.wait=true
    -Dsonar.projectKey=$SONAR_PROJECT_KEY
    -Dsonar.sources=src
    -Dsonar.sourceEncoding=UTF-8
    -Dsonar.inclusions=**/*.bsl
    -Dsonar.exclusions=**/*.bin
    -Dsonar.bsl.languageserver.enabled=true
    -Dsonar.bsl.languageserver.diagnosticLanguage=ru
    -Dsonar.scm.provider=git
    -Dsonar.scm.exclusions.disabled=true
    -Dsonar.host.url=$SONAR_HOST_URL
    -Dsonar.login=$SONAR_PROJECT_TOKEN
    -Dsonar.analysis.project_id=$CI_PROJECT_ID
    -Dsonar.analysis.commit_sha=$CI_COMMIT_SHA
    -Dsonar.analysis.ci_merge_request_iid=$CI_MERGE_REQUEST_IID
    -Dfile.encoding=UTF-8


sonar-job_MR:
  stage: checkcode
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
  script:
    - echo "Checking the code..."
    - Start-Process ${SONAR_PROCESS}  -Wait  -ArgumentList "${SONAR_ARGUMENTS}  " 
    - echo "Checking complete."


sonar-job_push:
  stage: checkcode
  rules:
    - if: $CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
  script:
    - echo "Checking the code..."
    - Start-Process ${SONAR_PROCESS}  -Wait  -ArgumentList "${SONAR_ARGUMENTS} -Dsonar.branch.name=${CI_COMMIT_BRANCH}" 
    - echo "Checking complete."

import groovy.json.JsonSlurperClassic

pipeline {
    agent { node { label 'built-in' } }

    triggers {
        GenericTrigger(
            genericVariables: [
                [key: 'sonar_properties', value: '$.properties'], // свойства с именем через точку
                [key: 'project', value: '$.project'],
                [key: 'branch', value: '$.branch'],
                [key: 'quality_gate', value: '$.qualityGate']
            ],
            causeString: 'Запущено по триггеру',
            token: 'comment_from_sonarqube',
            printContributedVariables: true,
            printPostContent: true,
            silentResponse: true
        )
    }
    environment {
        gitlab_token_id = "gitlab_token_id" // токен для гитлаба для помещенеия комментария
        gitlab_url = "https://***" // урл Гитлаба 
        urlSonar = "https://****:9443/" // урл сонара для замены на универсальный алиас 
        urlAliasSonar = "https://*****:9443/" // урл Алиаса сонара для подмены. Универсальный вход для сторонних разработчиков 
    }
    

    stages {
        // -------------------------------------------------
        stage('Отправка комментария') {
            steps {
                script {

                    def myObject = new JsonSlurperClassic().parseText(branch)
                    def branch_url = myObject["url"]
                    def branch_isMain = myObject["isMain"].toBoolean()

                    if (branch_isMain) {
                        echo "Для основной ветки отправка комментариев не предусмотрена"
                    } else {

                        myObject = new JsonSlurperClassic().parseText(sonar_properties)
                        def git_project_id = myObject["sonar.analysis.project_id"]
                        def git_commit_sha = myObject["sonar.analysis.commit_sha"]
                        def git_ci_merge_request_iid = myObject["sonar.analysis.ci_merge_request_iid"]

                        myObject = new JsonSlurperClassic().parseText(quality_gate)
                        qualityGate_status = myObject["status"]
                        // обработка массива метрик
                        def text_conditions = ""
                        for (cond in myObject["conditions"]) {
                            text_conditions = text_conditions + "- " + cond.metric + ": " + cond.value + " (*" + cond.status + "*)\r\n"
                        }

                        // урл для перехода
                        if (branch_url != null) {
                            result_sonar_url = branch_url
                        } else {
                            myObject = new JsonSlurperClassic().parseText(project)
                            result_sonar_url = myObject["url"]
                        }
                        // замена на алиас
                        result_sonar_url = result_sonar_url.replace(env.urlSonar, env.urlAliasSonar)
                        result_sonar_url = java.net.URLEncoder.encode(result_sonar_url, "UTF-8")

                        result_text = "[SonarQube](" + result_sonar_url + ") Quality gate: **" + qualityGate_status + "**\r\n\r\n" + text_conditions

                        def detectedMR = git_project_id != null && git_commit_sha != null && git_ci_merge_request_iid != null
                        if (detectedMR) {

                            comment_url = env.gitlab_url + "api/v4/projects/${git_project_id}/merge_requests/${git_ci_merge_request_iid}/discussions"
                            buildstatus_url = env.gitlab_url + "api/v4/projects/${git_project_id}/statuses/${git_commit_sha}"

                            add_comment(
                                comment_url,
                                result_text
                            )
                        }
                    } 
                }
            }
        }
    }
}

def add_comment(comment_url,text) {
    post_to_gitlab(comment_url, "body=${text}")
}

def add_status(buildstatus_url, text) {
    post_to_gitlab(buildstatus_url, "state=${text}")
}

def post_to_gitlab(url,    text) {
    withCredentials([string(credentialsId: env.gitlab_token_id, variable: 'TOKEN')]) {
        def response = httpRequest     (httpMode: 'POST', 
            requestBody: "${text}",
            customHeaders: [[name: "private-token", value: env.TOKEN],
                [name: 'Content-Type',value:'application/x-www-form-urlencoded']
                ],
            url: "${url}",
            ignoreSslErrors: true,
            quiet: true)
        println('Status: '+response.status)
        println('Response: '+response.content)
    }
}