scripts/get_maintainer.py

#!/usr/bin/env python3
#
# Copyright (c) 2019, Linaro Limited
#
# SPDX-License-Identifier: BSD-2-Clause

from pathlib import PurePath
from urllib.request import urlopen

import argparse
import glob
import os
import re
import tempfile


DIFF_GIT_RE = re.compile(r'^diff --git a/(?P<path>.*) ')
REVIEWED_RE = re.compile(r'^Reviewed-by: (?P<approver>.*>)')
ACKED_RE = re.compile(r'^Acked-by: (?P<approver>.*>)')
PATCH_START = re.compile(r'^From [0-9a-f]{40}')


def get_args():
    parser = argparse.ArgumentParser(description='Print the maintainers for '
                                     'the given source files or directories; '
                                     'or for the files modified by a patch or '
                                     'a pull request. '
                                     '(With -m) Check if a patch or pull '
                                     'request is properly Acked/Reviewed for '
                                     'merging.')
    parser.add_argument('-m', '--merge-check', action='store_true',
                        help='use Reviewed-by: and Acked-by: tags found in '
                        'patches to prevent display of information for all '
                        'the approved paths.')
    parser.add_argument('-p', '--show-paths', action='store_true',
                        help='show all paths that are not approved.')
    parser.add_argument('-s', '--strict', action='store_true',
                        help='stricter conditions for patch approval check: '
                        'subsystem "THE REST" is ignored for paths that '
                        'match some other subsystem.')
    parser.add_argument('arg', nargs='*', help='file or patch')
    parser.add_argument('-f', '--file', action='append',
                        help='treat following argument as a file path, not '
                        'a patch.')
    parser.add_argument('-g', '--github-pr', action='append', type=int,
                        help='Github pull request ID. The script will '
                        'download the patchset from Github to a temporary '
                        'file and process it.')
    return parser.parse_args()


# Parse MAINTAINERS and return a dictionary of subsystems such as:
# {'Subsystem name': {'R': ['foo', 'bar'], 'S': ['Maintained'],
#                     'F': [ 'path1', 'path2' ]}, ...}
def parse_maintainers():
    subsystems = {}
    cwd = os.getcwd()
    parent = os.path.dirname(os.path.realpath(__file__)) + "/../"
    if (os.path.realpath(cwd) != os.path.realpath(parent)):
        print("Error: this script must be run from the top-level of the "
              "optee_os tree")
        exit(1)
    with open("MAINTAINERS", "r") as f:
        start_found = False
        ss = {}
        name = ''
        for line in f:
            line = line.strip()
            if not line:
                continue
            if not start_found:
                if line.startswith("----------"):
                    start_found = True
                continue

            if line[1] == ':':
                letter = line[0]
                if (not ss.get(letter)):
                    ss[letter] = []
                ss[letter].append(line[3:])
            else:
                if name:
                    subsystems[name] = ss
                name = line
                ss = {}
        if name:
            subsystems[name] = ss

    return subsystems


# If @patchset is a patchset files and contains 2 patches or more, write
# individual patches to temporary files and return the paths.
# Otherwise return [].
def split_patchset(patchset):
    psname = os.path.basename(patchset).replace('.', '_')
    patchnum = 0
    of = None
    ret = []
    f = None
    try:
        f = open(patchset, "r")
    except OSError:
        return []
    for line in f:
        match = re.search(PATCH_START, line)
        if match:
            # New patch found: create new file
            patchnum += 1
            prefix = "{}_{}_".format(patchnum, psname)
            of = tempfile.NamedTemporaryFile(mode="w", prefix=prefix,
                                             suffix=".patch",
                                             delete=False)
            ret.append(of.name)
        if of:
            of.write(line)
    if len(ret) >= 2:
        return ret
    if len(ret) == 1:
        os.remove(ret[0])
    return []


# If @path is a patch file, returns the paths touched by the patch as well
# as the content of the review/ack tags
def get_paths_from_patch(patch):
    paths = []
    approvers = []
    try:
        with open(patch, "r") as f:
            for line in f:
                match = re.search(DIFF_GIT_RE, line)
                if match:
                    p = match.group('path')
                    if p not in paths:
                        paths.append(p)
                    continue
                match = re.search(REVIEWED_RE, line)
                if match:
                    a = match.group('approver')
                    if a not in approvers:
                        approvers.append(a)
                    continue
                match = re.search(ACKED_RE, line)
                if match:
                    a = match.group('approver')
                    if a not in approvers:
                        approvers.append(a)
                    continue
    except Exception:
        pass
    return (paths, approvers)


# Does @path match @pattern?
# @pattern has the syntax defined in the Linux MAINTAINERS file -- mostly a
# shell glob pattern, except that a trailing slash means a directory and
# everything below. Matching can easily be done by converting to a regexp.
def match_pattern(path, pattern):
    # Append a trailing slash if path is an existing directory, so that it
    # matches F: entries such as 'foo/bar/'
    if not path.endswith('/') and os.path.isdir(path):
        path += '/'
    rep = "^" + pattern
    rep = rep.replace('*', '[^/]+')
    rep = rep.replace('?', '[^/]')
    if rep.endswith('/'):
        rep += '.*'
    rep += '$'
    return not not re.match(rep, path)


def get_subsystems_for_path(subsystems, path, strict):
    found = {}
    for key in subsystems:
        def inner():
            excluded = subsystems[key].get('X')
            if excluded:
                for pattern in excluded:
                    if match_pattern(path, pattern):
                        return  # next key
            included = subsystems[key].get('F')
            if not included:
                return  # next key
            for pattern in included:
                if match_pattern(path, pattern):
                    found[key] = subsystems[key]
        inner()
    if strict and len(found) > 1:
        found.pop('THE REST', None)
    return found


def get_ss_maintainers(subsys):
    return subsys.get('M') or []


def get_ss_reviewers(subsys):
    return subsys.get('R') or []


def get_ss_approvers(ss):
    return get_ss_maintainers(ss) + get_ss_reviewers(ss)


def approvers_have_approved(approved_by, approvers):
    for n in approvers:
        # Ignore anything after the email (Github ID...)
        n = n.split('>', 1)[0]
        for m in approved_by:
            m = m.split('>', 1)[0]
            if n == m:
                return True
    return False


def download(pr):
    url = "https://github.com/OP-TEE/optee_os/pull/{}.patch".format(pr)
    f = tempfile.NamedTemporaryFile(mode="wb", prefix="pr{}_".format(pr),
                                    suffix=".patch", delete=False)
    print("Downloading {}...".format(url), end='', flush=True)
    f.write(urlopen(url).read())
    print(" Done.")
    return f.name


def main():
    global args

    args = get_args()
    all_subsystems = parse_maintainers()
    paths = []
    arglist = []
    downloads = []
    split_patches = []

    for pr in args.github_pr or []:
        downloads += [download(pr)]

    for arg in args.arg + downloads:
        if os.path.exists(arg):
            patches = split_patchset(arg)
            if patches:
                split_patches += patches
                continue
        arglist.append(arg)

    for arg in arglist + split_patches:
        patch_paths = []
        approved_by = []
        if os.path.exists(arg):
            # Try to parse as a patch
            (patch_paths, approved_by) = get_paths_from_patch(arg)
        if not patch_paths:
            # Not a patch, consider the path itself
            # as_posix() cleans the path a little bit (suppress leading ./ and
            # duplicate slashes...)
            patch_paths = [PurePath(arg).as_posix()]
        for path in patch_paths:
            approved = False
            if args.merge_check:
                ss_for_path = get_subsystems_for_path(all_subsystems, path,
                                                      args.strict)
                for key in ss_for_path:
                    ss_approvers = get_ss_approvers(ss_for_path[key])
                    if approvers_have_approved(approved_by, ss_approvers):
                        approved = True
            if not approved:
                paths += [path]

    for f in downloads + split_patches:
        os.remove(f)

    if args.file:
        paths += args.file

    if (args.show_paths):
        print(paths)

    ss = {}
    for path in paths:
        ss.update(get_subsystems_for_path(all_subsystems, path, args.strict))
    for key in ss:
        ss_name = key[:50] + (key[50:] and '...')
        for name in ss[key].get('M') or []:
            print("{} (maintainer:{})".format(name, ss_name))
        for name in ss[key].get('R') or []:
            print("{} (reviewer:{})".format(name, ss_name))


if __name__ == "__main__":
    main()