llvm-premerge-checks/scripts/summary.py

#!/usr/bin/env python3
# Copyright 2020 Google LLC
#
# Licensed under the the Apache License v2.0 with LLVM Exceptions (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse
import logging
import os
from typing import Any, Tuple

from phabtalk.phabtalk import PhabTalk
from buildkite_utils import format_url, BuildkiteApi, strip_emojis
import xunit_utils
from command_utils import get_env_or_die
from benedict import benedict
from dataclasses import dataclass


def get_failed_jobs(build: benedict) -> []:
    failed_jobs = []
    for j in build.get('jobs', []):
        j = benedict(j)
        if j.get('state') == 'failed' and j.get('name'):
            failed_jobs.append(j.get('name'))
    return failed_jobs


@dataclass
class jobResult:
    name: str
    url: str
    sub: list
    success: bool
    tests: list

# Returns list of jobs in the build and success flag.
def process_build(bk: BuildkiteApi, build: benedict) -> Tuple[list[jobResult], bool]:
    logging.info(f"Processing build {build.get('id')} {build.get('pipeline.name')}. All jobs:")
    for job in build.get('jobs', []):
        logging.info(f'job ID={job.get("id")} NAME={job.get("name")} type={job.get("type")} state={job.get("state")}')
    success = True
    result = []
    for job in build.get('jobs', []):
        job = benedict(job)
        job_type = job.get('type')
        logging.info(f'Processing job ID={job.get("id")}')
        if job.get('id') == os.getenv("BUILDKITE_JOB_ID"):
            logging.info("job ID matches current job, ignoring")
            continue
        job_state = job.get('state')
        if job_type == 'waiter':
            logging.info('job type is "waiter", ignoring')
            continue
        name = job.get('name')
        if (name is None) or (strip_emojis(name).strip() == ''):
            name = f"({job.get('type')})"
        logging.info(f"name {name}")
        name = strip_emojis(name)
        j = jobResult(
            name=name,
            sub=[],
            success=job_state=='passed',
            tests=fetch_job_unit_tests(job),
            url=job.get('web_url',''))
        if job.get('type') == 'trigger':
            triggered_url = job.get('triggered_build.url')
            logging.info(f'processing a trigger build from {triggered_url}')
            if triggered_url != '':
                sub_build = benedict(bk.get(triggered_url).json())
                j.name = sub_build.get('pipeline.name')
                j.url = sub_build.get('web_url')
                j.sub, s = process_build(bk, sub_build)
                j.success = j.success and s
        result.append(j)
        success = success and j.success
    return [result, success]

# Returns a list of failed tests from a failed script job.
def fetch_job_unit_tests(job: benedict) -> list[Any]:
    if job.get('state') != 'failed' or job.get('type') != 'script':
        logging.info(f"skipping job with state {job.get('state')} and type {job.get('type')}, only failed scripts are considered")
        return []
    artifacts_url = job.get('artifacts_url')
    if artifacts_url is None:
        logging.warning('job has not artifacts')
        return []
    artifacts = bk.get(artifacts_url).json()
    for a in artifacts:
        a = benedict(a)
        if not a.get('filename').endswith('test-results.xml') or not a.get('download_url'):
            continue
        content = bk.get(a.get('download_url')).content
        ctx = strip_emojis(job.get('name', build.get('pipeline.name')))
        return xunit_utils.parse_failures(content, ctx)
    logging.info('file test-results.xml not found')
    return []

def print_jobs(jobs: list[jobResult], pad: str):
    for j in jobs:
        print(f"{pad} {j.name} {j.success}")
        print_jobs(j.sub, pad + '  ')

# Returns a flat list of job tests, appends prefix of job names to test names.
def flatten_tests(jobs: list[jobResult], prefix: str) -> list[Any]:
    t = []
    for j in jobs:
        t.extend(xunit_utils.add_context_prefix(j.tests, prefix))
        t.extend(flatten_tests(j.sub, f"{prefix}{j.name} - "))
    return t

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--log-level', type=str, default='INFO')
    parser.add_argument('--debug', action='store_true')
    args = parser.parse_args()
    logging.basicConfig(level=args.log_level, format='%(levelname)-7s %(message)s')
    bk_api_token = get_env_or_die('BUILDKITE_API_TOKEN')
    bk_pipeline_slug = get_env_or_die('BUILDKITE_PIPELINE_SLUG')
    bk_organization_slug = get_env_or_die("BUILDKITE_ORGANIZATION_SLUG")
    bk_build_number = get_env_or_die("BUILDKITE_BUILD_NUMBER")
    dry_run=os.getenv('ph_dry_run_report') is not None
    if dry_run:
      logging.info('running in dry-run mode, not exchanging with phabricator')
    ph_buildable_diff = os.getenv('ph_buildable_diff')
    conduit_token = get_env_or_die('CONDUIT_TOKEN')
    ph_target_phid = 'ph_target_phid'
    if not dry_run:
        ph_target_phid = get_env_or_die('ph_target_phid')
    phabtalk = PhabTalk(conduit_token, dry_run_updates=dry_run)
    report_success = False  # for try block
    failed_tests = []
    try:
        bk = BuildkiteApi(bk_api_token, bk_organization_slug)
        # Build type is https://buildkite.com/docs/apis/rest-api/builds#get-a-build.
        build = bk.get_build(bk_pipeline_slug, bk_build_number)
        jobs, success = process_build(bk, build)
        failed_tests = flatten_tests(jobs, '')
        if args.debug:
            print_jobs(jobs, '')
            for t in failed_tests:
                t['details'] = ''
        for j in jobs:
            if not j.success:
                phabtalk.maybe_add_url_artifact(ph_target_phid, j.url, j.name + " FAILED")
        report_success = success
    finally:
        build_url = f'https://reviews.llvm.org/harbormaster/build/{os.getenv("ph_build_id")}'
        print(f'Reporting results to Phabricator build {format_url(build_url)}', flush=True)
        phabtalk.update_build_status(ph_target_phid, False, report_success, {}, failed_tests)