rust/src/tools/publish_toolstate.py

353 lines
12 KiB
Python
Raw Normal View History

#!/usr/bin/env python
# -*- coding: utf-8 -*-
2020-03-04 03:17:15 -06:00
# This script computes the new "current" toolstate for the toolstate repo (not to be
# confused with publishing the test results, which happens in `src/bootstrap/toolstate.rs`).
# It gets called from `src/ci/publish_toolstate.sh` when a new commit lands on `master`
# (i.e., after it passed all checks on `auto`).
2019-07-23 03:50:45 -05:00
from __future__ import print_function
import sys
import re
import os
import json
import datetime
import collections
import textwrap
try:
import urllib2
except ImportError:
import urllib.request as urllib2
2019-03-09 00:28:25 -06:00
# List of people to ping when the status of a tool or a book changed.
# These should be collaborators of the rust-lang/rust repository (with at least
# read privileges on it). CI will fail otherwise.
MAINTAINERS = {
'miri': {'oli-obk', 'RalfJung', 'eddyb'},
'rls': {'Xanewok'},
'rustfmt': {'topecongiro', 'calebcartwright'},
'book': {'carols10cents', 'steveklabnik'},
'nomicon': {'frewsxcv', 'Gankra'},
'reference': {'steveklabnik', 'Havvy', 'matthewjasper', 'ehuss'},
'rust-by-example': {'steveklabnik', 'marioidival'},
'embedded-book': {'adamgreig', 'andre-richter', 'jamesmunns', 'therealprof'},
2020-04-15 11:19:02 -05:00
'edition-guide': {'ehuss', 'steveklabnik'},
'rustc-dev-guide': {'mark-i-m', 'spastorino', 'amanjeev', 'JohnTitor'},
}
LABELS = {
'miri': ['A-miri', 'C-bug'],
'rls': ['A-rls', 'C-bug'],
'rustfmt': ['A-rustfmt', 'C-bug'],
'book': ['C-bug'],
'nomicon': ['C-bug'],
'reference': ['C-bug'],
'rust-by-example': ['C-bug'],
'embedded-book': ['C-bug'],
'edition-guide': ['C-bug'],
'rustc-dev-guide': ['C-bug'],
}
2018-12-19 10:44:46 -06:00
REPOS = {
'miri': 'https://github.com/rust-lang/miri',
2018-12-19 10:44:46 -06:00
'rls': 'https://github.com/rust-lang/rls',
'rustfmt': 'https://github.com/rust-lang/rustfmt',
'book': 'https://github.com/rust-lang/book',
'nomicon': 'https://github.com/rust-lang/nomicon',
'reference': 'https://github.com/rust-lang/reference',
2018-12-19 10:44:46 -06:00
'rust-by-example': 'https://github.com/rust-lang/rust-by-example',
2019-03-09 00:28:25 -06:00
'embedded-book': 'https://github.com/rust-embedded/book',
'edition-guide': 'https://github.com/rust-lang/edition-guide',
'rustc-dev-guide': 'https://github.com/rust-lang/rustc-dev-guide',
2018-12-19 10:44:46 -06:00
}
2019-11-21 06:57:40 -06:00
def load_json_from_response(resp):
content = resp.read()
if isinstance(content, bytes):
content = content.decode('utf-8')
else:
print("Refusing to decode " + str(type(content)) + " to str")
return json.loads(content)
def validate_maintainers(repo, github_token):
'''Ensure all maintainers are assignable on a GitHub repo'''
next_link_re = re.compile(r'<([^>]+)>; rel="next"')
# Load the list of assignable people in the GitHub repo
assignable = []
url = 'https://api.github.com/repos/%s/collaborators?per_page=100' % repo
while url is not None:
response = urllib2.urlopen(urllib2.Request(url, headers={
'Authorization': 'token ' + github_token,
# Properly load nested teams.
'Accept': 'application/vnd.github.hellcat-preview+json',
}))
2019-11-21 06:57:40 -06:00
assignable.extend(user['login'] for user in load_json_from_response(response))
# Load the next page if available
url = None
link_header = response.headers.get('Link')
if link_header:
matches = next_link_re.match(link_header)
if matches is not None:
url = matches.group(1)
errors = False
for tool, maintainers in MAINTAINERS.items():
for maintainer in maintainers:
if maintainer not in assignable:
errors = True
print(
"error: %s maintainer @%s is not assignable in the %s repo"
% (tool, maintainer, repo),
)
if errors:
print()
print(" To be assignable, a person needs to be explicitly listed as a")
print(" collaborator in the repository settings. The simple way to")
print(" fix this is to ask someone with 'admin' privileges on the repo")
print(" to add the person or whole team as a collaborator with 'read'")
print(" privileges. Those privileges don't grant any extra permissions")
print(" so it's safe to apply them.")
print()
print("The build will fail due to this.")
exit(1)
2020-02-07 21:30:11 -06:00
def read_current_status(current_commit, path):
'''Reads build status of `current_commit` from content of `history/*.tsv`
'''
with open(path, 'rU') as f:
for line in f:
(commit, status) = line.split('\t', 1)
if commit == current_commit:
return json.loads(status)
return {}
2020-02-07 21:30:11 -06:00
def gh_url():
return os.environ['TOOLSTATE_ISSUES_API_URL']
2020-02-07 21:30:11 -06:00
def maybe_delink(message):
if os.environ.get('TOOLSTATE_SKIP_MENTIONS') is not None:
return message.replace("@", "")
return message
2020-02-07 21:30:11 -06:00
def issue(
tool,
status,
assignees,
relevant_pr_number,
relevant_pr_user,
labels,
):
# Open an issue about the toolstate failure.
if status == 'test-fail':
status_description = 'has failing tests'
else:
status_description = 'no longer builds'
request = json.dumps({
'body': maybe_delink(textwrap.dedent('''\
Hello, this is your friendly neighborhood mergebot.
After merging PR {}, I observed that the tool {} {}.
A follow-up PR to the repository {} is needed to fix the fallout.
cc @{}, do you think you would have time to do the follow-up work?
If so, that would be great!
2018-12-19 08:54:51 -06:00
And nominating for compiler team prioritization.
2018-12-19 08:54:51 -06:00
''').format(
relevant_pr_number, tool, status_description,
REPOS.get(tool), relevant_pr_user
)),
'title': '`{}` no longer builds after {}'.format(tool, relevant_pr_number),
'assignees': list(assignees),
'labels': labels,
})
print("Creating issue:\n{}".format(request))
response = urllib2.urlopen(urllib2.Request(
gh_url(),
request,
{
'Authorization': 'token ' + github_token,
'Content-Type': 'application/json',
}
))
response.read()
2020-02-07 21:30:11 -06:00
def update_latest(
current_commit,
relevant_pr_number,
relevant_pr_url,
relevant_pr_user,
2018-12-19 10:44:46 -06:00
pr_reviewer,
current_datetime
):
'''Updates `_data/latest.json` to match build result of the given commit.
'''
2019-11-21 06:57:40 -06:00
with open('_data/latest.json', 'r+') as f:
latest = json.load(f, object_pairs_hook=collections.OrderedDict)
current_status = {
os: read_current_status(current_commit, 'history/' + os + '.tsv')
for os in ['windows', 'linux']
}
slug = 'rust-lang/rust'
message = textwrap.dedent('''\
📣 Toolstate changed by {}!
Tested on commit {}@{}.
Direct link to PR: <{}>
''').format(relevant_pr_number, slug, current_commit, relevant_pr_url)
anything_changed = False
for status in latest:
tool = status['tool']
changed = False
2020-02-07 21:30:11 -06:00
create_issue_for_status = None # set to the status that caused the issue
for os, s in current_status.items():
old = status[os]
new = s.get(tool, old)
status[os] = new
maintainers = ' '.join('@'+name for name in MAINTAINERS.get(tool, ()))
# comparing the strings, but they are ordered appropriately:
# "test-pass" > "test-fail" > "build-fail"
if new > old:
# things got fixed or at least the status quo improved
changed = True
message += '🎉 {} on {}: {}{} (cc {}).\n' \
.format(tool, os, old, new, maintainers)
elif new < old:
# tests or builds are failing and were not failing before
changed = True
title = '💔 {} on {}: {}{}' \
.format(tool, os, old, new)
message += '{} (cc {}).\n' \
.format(title, maintainers)
# See if we need to create an issue.
if tool == 'miri':
# Create issue if tests used to pass before. Don't open a *second*
# issue when we regress from "test-fail" to "build-fail".
if old == 'test-pass':
create_issue_for_status = new
else:
# Create issue if things no longer build.
# (No issue for mere test failures to avoid spurious issues.)
if new == 'build-fail':
create_issue_for_status = new
2018-12-19 08:54:51 -06:00
if create_issue_for_status is not None:
try:
issue(
tool, create_issue_for_status, MAINTAINERS.get(tool, ''),
relevant_pr_number, relevant_pr_user, LABELS.get(tool, ''),
)
2019-06-21 12:22:46 -05:00
except urllib2.HTTPError as e:
# network errors will simply end up not creating an issue, but that's better
# than failing the entire build job
2019-06-21 13:47:42 -05:00
print("HTTPError when creating issue for status regression: {0}\n{1}"
.format(e, e.read()))
2019-06-21 12:22:46 -05:00
except IOError as e:
print("I/O error when creating issue for status regression: {0}".format(e))
except:
2019-06-21 07:07:20 -05:00
print("Unexpected error when creating issue for status regression: {0}"
.format(sys.exc_info()[0]))
raise
if changed:
status['commit'] = current_commit
status['datetime'] = current_datetime
anything_changed = True
if not anything_changed:
return ''
f.seek(0)
f.truncate(0)
json.dump(latest, f, indent=4, separators=(',', ': '))
return message
def main():
repo = os.environ.get('TOOLSTATE_VALIDATE_MAINTAINERS_REPO')
if repo:
github_token = os.environ.get('TOOLSTATE_REPO_ACCESS_TOKEN')
if github_token:
validate_maintainers(repo, github_token)
else:
print('skipping toolstate maintainers validation since no GitHub token is present')
# When validating maintainers don't run the full script.
exit(0)
cur_commit = sys.argv[1]
cur_datetime = datetime.datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ')
cur_commit_msg = sys.argv[2]
save_message_to_path = sys.argv[3]
github_token = sys.argv[4]
# assume that PR authors are also owners of the repo where the branch lives
2018-12-20 07:29:42 -06:00
relevant_pr_match = re.search(
r'Auto merge of #([0-9]+) - ([^:]+):[^,]+, r=(\S+)',
2018-12-20 07:29:42 -06:00
cur_commit_msg,
)
if relevant_pr_match:
number = relevant_pr_match.group(1)
relevant_pr_user = relevant_pr_match.group(2)
relevant_pr_number = 'rust-lang/rust#' + number
relevant_pr_url = 'https://github.com/rust-lang/rust/pull/' + number
2018-12-19 10:44:46 -06:00
pr_reviewer = relevant_pr_match.group(3)
else:
number = '-1'
relevant_pr_user = 'ghost'
relevant_pr_number = '<unknown PR>'
relevant_pr_url = '<unknown>'
pr_reviewer = 'ghost'
message = update_latest(
cur_commit,
relevant_pr_number,
relevant_pr_url,
relevant_pr_user,
2018-12-19 10:44:46 -06:00
pr_reviewer,
cur_datetime
)
if not message:
print('<Nothing changed>')
sys.exit(0)
print(message)
if not github_token:
print('Dry run only, not committing anything')
sys.exit(0)
with open(save_message_to_path, 'w') as f:
f.write(message)
# Write the toolstate comment on the PR as well.
issue_url = gh_url() + '/{}/comments'.format(number)
response = urllib2.urlopen(urllib2.Request(
issue_url,
json.dumps({'body': maybe_delink(message)}),
{
'Authorization': 'token ' + github_token,
'Content-Type': 'application/json',
}
))
response.read()
if __name__ == '__main__':
try:
main()
except urllib2.HTTPError as e:
print("HTTPError: %s\n%s" % (e, e.read()))
raise