fec3cee0bb
Refactor the skip collaborator logic to add log messages when a collaborator is skipped because they self removed of not part of the org. Signed-off-by: Fabio Baltieri <fabiobaltieri@google.com>
382 lines
12 KiB
Python
Executable file
382 lines
12 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
|
|
# Copyright (c) 2022 Intel Corp.
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
|
|
import argparse
|
|
import sys
|
|
import os
|
|
import time
|
|
import datetime
|
|
from github import Github, GithubException
|
|
from github.GithubException import UnknownObjectException
|
|
from collections import defaultdict
|
|
from west.manifest import Manifest
|
|
from west.manifest import ManifestProject
|
|
|
|
TOP_DIR = os.path.join(os.path.dirname(__file__))
|
|
sys.path.insert(0, os.path.join(TOP_DIR, "scripts"))
|
|
from get_maintainer import Maintainers
|
|
|
|
def log(s):
|
|
if args.verbose > 0:
|
|
print(s, file=sys.stdout)
|
|
|
|
def parse_args():
|
|
global args
|
|
parser = argparse.ArgumentParser(
|
|
description=__doc__,
|
|
formatter_class=argparse.RawDescriptionHelpFormatter, allow_abbrev=False)
|
|
|
|
parser.add_argument("-M", "--maintainer-file", required=False, default="MAINTAINERS.yml",
|
|
help="Maintainer file to be used.")
|
|
|
|
group = parser.add_mutually_exclusive_group()
|
|
group.add_argument("-P", "--pull_request", required=False, default=None, type=int,
|
|
help="Operate on one pull-request only.")
|
|
group.add_argument("-I", "--issue", required=False, default=None, type=int,
|
|
help="Operate on one issue only.")
|
|
group.add_argument("-s", "--since", required=False,
|
|
help="Process pull-requests since date.")
|
|
group.add_argument("-m", "--modules", action="store_true",
|
|
help="Process pull-requests from modules.")
|
|
|
|
parser.add_argument("-y", "--dry-run", action="store_true", default=False,
|
|
help="Dry run only.")
|
|
|
|
parser.add_argument("-o", "--org", default="zephyrproject-rtos",
|
|
help="Github organisation")
|
|
|
|
parser.add_argument("-r", "--repo", default="zephyr",
|
|
help="Github repository")
|
|
|
|
parser.add_argument("-v", "--verbose", action="count", default=0,
|
|
help="Verbose Output")
|
|
|
|
args = parser.parse_args()
|
|
|
|
def process_pr(gh, maintainer_file, number):
|
|
|
|
gh_repo = gh.get_repo(f"{args.org}/{args.repo}")
|
|
pr = gh_repo.get_pull(number)
|
|
|
|
log(f"working on https://github.com/{args.org}/{args.repo}/pull/{pr.number} : {pr.title}")
|
|
|
|
labels = set()
|
|
area_counter = defaultdict(int)
|
|
found_maintainers = defaultdict(int)
|
|
|
|
num_files = 0
|
|
all_areas = set()
|
|
fn = list(pr.get_files())
|
|
|
|
manifest_change = False
|
|
for changed_file in fn:
|
|
if changed_file.filename in ['west.yml','submanifests/optional.yaml']:
|
|
manifest_change = True
|
|
break
|
|
|
|
# one liner PRs should be trivial
|
|
if pr.commits == 1 and (pr.additions <= 1 and pr.deletions <= 1) and not manifest_change:
|
|
labels = {'Trivial'}
|
|
|
|
if len(fn) > 500:
|
|
log(f"Too many files changed ({len(fn)}), skipping....")
|
|
return
|
|
|
|
for changed_file in fn:
|
|
num_files += 1
|
|
log(f"file: {changed_file.filename}")
|
|
areas = maintainer_file.path2areas(changed_file.filename)
|
|
|
|
if not areas:
|
|
continue
|
|
|
|
all_areas.update(areas)
|
|
is_instance = False
|
|
sorted_areas = sorted(areas, key=lambda x: 'Platform' in x.name, reverse=True)
|
|
for area in sorted_areas:
|
|
c = 1 if not is_instance else 0
|
|
|
|
area_counter[area] += c
|
|
labels.update(area.labels)
|
|
# FIXME: Here we count the same file multiple times if it exists in
|
|
# multiple areas with same maintainer
|
|
for area_maintainer in area.maintainers:
|
|
found_maintainers[area_maintainer] += c
|
|
|
|
if 'Platform' in area.name:
|
|
is_instance = True
|
|
|
|
area_counter = dict(sorted(area_counter.items(), key=lambda item: item[1], reverse=True))
|
|
log(f"Area matches: {area_counter}")
|
|
log(f"labels: {labels}")
|
|
|
|
# Create a list of collaborators ordered by the area match
|
|
collab = list()
|
|
for area in area_counter:
|
|
collab += maintainer_file.areas[area.name].maintainers
|
|
collab += maintainer_file.areas[area.name].collaborators
|
|
collab = list(dict.fromkeys(collab))
|
|
log(f"collab: {collab}")
|
|
|
|
_all_maintainers = dict(sorted(found_maintainers.items(), key=lambda item: item[1], reverse=True))
|
|
|
|
log(f"Submitted by: {pr.user.login}")
|
|
log(f"candidate maintainers: {_all_maintainers}")
|
|
|
|
maintainers = list(_all_maintainers.keys())
|
|
assignee = None
|
|
|
|
# we start with areas with most files changed and pick the maintainer from the first one.
|
|
# if the first area is an implementation, i.e. driver or platform, we
|
|
# continue searching for any other areas
|
|
for area, count in area_counter.items():
|
|
if count == 0:
|
|
continue
|
|
if len(area.maintainers) > 0:
|
|
assignee = area.maintainers[0]
|
|
|
|
if 'Platform' not in area.name:
|
|
break
|
|
|
|
# if the submitter is the same as the maintainer, check if we have
|
|
# multiple maintainers
|
|
if len(maintainers) > 1 and pr.user.login == assignee:
|
|
log("Submitter is same as Assignee, trying to find another assignee...")
|
|
aff = list(area_counter.keys())[0]
|
|
for area in all_areas:
|
|
if area == aff:
|
|
if len(area.maintainers) > 1:
|
|
assignee = area.maintainers[1]
|
|
else:
|
|
log(f"This area has only one maintainer, keeping assignee as {assignee}")
|
|
|
|
if assignee:
|
|
prop = (found_maintainers[assignee] / num_files) * 100
|
|
log(f"Picked assignee: {assignee} ({prop:.2f}% ownership)")
|
|
log("+++++++++++++++++++++++++")
|
|
|
|
# Set labels
|
|
if labels:
|
|
if len(labels) < 10:
|
|
for l in labels:
|
|
log(f"adding label {l}...")
|
|
if not args.dry_run:
|
|
pr.add_to_labels(l)
|
|
else:
|
|
log(f"Too many labels to be applied")
|
|
|
|
if collab:
|
|
reviewers = []
|
|
existing_reviewers = set()
|
|
|
|
revs = pr.get_reviews()
|
|
for review in revs:
|
|
existing_reviewers.add(review.user)
|
|
|
|
rl = pr.get_review_requests()
|
|
page = 0
|
|
for r in rl:
|
|
existing_reviewers |= set(r.get_page(page))
|
|
page += 1
|
|
|
|
# check for reviewers that remove themselves from list of reviewer and
|
|
# do not attempt to add them again based on MAINTAINERS file.
|
|
self_removal = []
|
|
for event in pr.get_issue_events():
|
|
if event.event == 'review_request_removed' and event.actor == event.requested_reviewer:
|
|
self_removal.append(event.actor)
|
|
|
|
for collaborator in collab:
|
|
try:
|
|
gh_user = gh.get_user(collaborator)
|
|
if pr.user == gh_user or gh_user in existing_reviewers:
|
|
continue
|
|
if not gh_repo.has_in_collaborators(gh_user):
|
|
log(f"Skip '{collaborator}': not in collaborators")
|
|
continue
|
|
if gh_user in self_removal:
|
|
log(f"Skip '{collaborator}': self removed")
|
|
continue
|
|
reviewers.append(collaborator)
|
|
except UnknownObjectException as e:
|
|
log(f"Can't get user '{collaborator}', account does not exist anymore? ({e})")
|
|
|
|
if len(existing_reviewers) < 15:
|
|
reviewer_vacancy = 15 - len(existing_reviewers)
|
|
reviewers = reviewers[:reviewer_vacancy]
|
|
|
|
if reviewers:
|
|
try:
|
|
log(f"adding reviewers {reviewers}...")
|
|
if not args.dry_run:
|
|
pr.create_review_request(reviewers=reviewers)
|
|
except GithubException:
|
|
log("cant add reviewer")
|
|
else:
|
|
log("not adding reviewers because the existing reviewer count is greater than or "
|
|
"equal to 15")
|
|
|
|
ms = []
|
|
# assignees
|
|
if assignee and not pr.assignee:
|
|
try:
|
|
u = gh.get_user(assignee)
|
|
ms.append(u)
|
|
except GithubException:
|
|
log(f"Error: Unknown user")
|
|
|
|
for mm in ms:
|
|
log(f"Adding assignee {mm}...")
|
|
if not args.dry_run:
|
|
pr.add_to_assignees(mm)
|
|
else:
|
|
log("not setting assignee")
|
|
|
|
time.sleep(1)
|
|
|
|
|
|
def process_issue(gh, maintainer_file, number):
|
|
gh_repo = gh.get_repo(f"{args.org}/{args.repo}")
|
|
issue = gh_repo.get_issue(number)
|
|
|
|
log(f"Working on {issue.url}: {issue.title}")
|
|
|
|
if issue.assignees:
|
|
print(f"Already assigned {issue.assignees}, bailing out")
|
|
return
|
|
|
|
label_to_maintainer = defaultdict(set)
|
|
for _, area in maintainer_file.areas.items():
|
|
if not area.labels:
|
|
continue
|
|
|
|
labels = set()
|
|
for label in area.labels:
|
|
labels.add(label.lower())
|
|
labels = tuple(sorted(labels))
|
|
|
|
for maintainer in area.maintainers:
|
|
label_to_maintainer[labels].add(maintainer)
|
|
|
|
# Add extra entries for areas with multiple labels so they match with just
|
|
# one label if it's specific enough.
|
|
for areas, maintainers in dict(label_to_maintainer).items():
|
|
for area in areas:
|
|
if tuple([area]) not in label_to_maintainer:
|
|
label_to_maintainer[tuple([area])] = maintainers
|
|
|
|
issue_labels = set()
|
|
for label in issue.labels:
|
|
label_name = label.name.lower()
|
|
if tuple([label_name]) not in label_to_maintainer:
|
|
print(f"Ignoring label: {label}")
|
|
continue
|
|
issue_labels.add(label_name)
|
|
issue_labels = tuple(sorted(issue_labels))
|
|
|
|
print(f"Using labels: {issue_labels}")
|
|
|
|
if issue_labels not in label_to_maintainer:
|
|
print(f"no match for the label set, not assigning")
|
|
return
|
|
|
|
for maintainer in label_to_maintainer[issue_labels]:
|
|
log(f"Adding {maintainer} to {issue.html_url}")
|
|
if not args.dry_run:
|
|
issue.add_to_assignees(maintainer)
|
|
|
|
|
|
def process_modules(gh, maintainers_file):
|
|
manifest = Manifest.from_file()
|
|
|
|
repos = {}
|
|
for project in manifest.get_projects([]):
|
|
if not manifest.is_active(project):
|
|
continue
|
|
|
|
if isinstance(project, ManifestProject):
|
|
continue
|
|
|
|
area = f"West project: {project.name}"
|
|
if area not in maintainers_file.areas:
|
|
log(f"No area for: {area}")
|
|
continue
|
|
|
|
maintainers = maintainers_file.areas[area].maintainers
|
|
if not maintainers:
|
|
log(f"No maintainers for: {area}")
|
|
continue
|
|
|
|
collaborators = maintainers_file.areas[area].collaborators
|
|
|
|
log(f"Found {area}, maintainers={maintainers}, collaborators={collaborators}")
|
|
|
|
repo_name = f"{args.org}/{project.name}"
|
|
repos[repo_name] = maintainers_file.areas[area]
|
|
|
|
query = f"is:open is:pr no:assignee"
|
|
for repo in repos:
|
|
query += f" repo:{repo}"
|
|
|
|
issues = gh.search_issues(query=query)
|
|
for issue in issues:
|
|
pull = issue.as_pull_request()
|
|
|
|
if pull.draft:
|
|
continue
|
|
|
|
if pull.assignees:
|
|
log(f"ERROR: {pull.html_url} should have no assignees, found {pull.assignees}")
|
|
continue
|
|
|
|
repo_name = f"{args.org}/{issue.repository.name}"
|
|
area = repos[repo_name]
|
|
|
|
for maintainer in area.maintainers:
|
|
log(f"Assigning {maintainer} to {pull.html_url}")
|
|
if not args.dry_run:
|
|
pull.add_to_assignees(maintainer)
|
|
pull.create_review_request(maintainer)
|
|
|
|
for collaborator in area.collaborators:
|
|
log(f"Adding {collaborator} to {pull.html_url}")
|
|
if not args.dry_run:
|
|
pull.create_review_request(collaborator)
|
|
|
|
|
|
def main():
|
|
parse_args()
|
|
|
|
token = os.environ.get('GITHUB_TOKEN', None)
|
|
if not token:
|
|
sys.exit('Github token not set in environment, please set the '
|
|
'GITHUB_TOKEN environment variable and retry.')
|
|
|
|
gh = Github(token)
|
|
maintainer_file = Maintainers(args.maintainer_file)
|
|
|
|
if args.pull_request:
|
|
process_pr(gh, maintainer_file, args.pull_request)
|
|
elif args.issue:
|
|
process_issue(gh, maintainer_file, args.issue)
|
|
elif args.modules:
|
|
process_modules(gh, maintainer_file)
|
|
else:
|
|
if args.since:
|
|
since = args.since
|
|
else:
|
|
today = datetime.date.today()
|
|
since = today - datetime.timedelta(days=1)
|
|
|
|
common_prs = f'repo:{args.org}/{args.repo} is:open is:pr base:main -is:draft no:assignee created:>{since}'
|
|
pulls = gh.search_issues(query=f'{common_prs}')
|
|
|
|
for issue in pulls:
|
|
process_pr(gh, maintainer_file, issue.number)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|