def test_select_comments(self):
c_api = CommentAPI(self.api.apiurl)
staging_b = 'openSUSE:Factory:Staging:B'
comments = c_api.get_comments(project_name=staging_b)
# First select
self.assertEqual(True, SelectCommand(self.api, staging_b).perform(['gcc', 'wine']))
first_select_comments = c_api.get_comments(project_name=staging_b)
last_id = sorted(first_select_comments.keys())[-1]
first_select_comment = first_select_comments[last_id]
# Only one comment is added
self.assertEqual(len(first_select_comments), len(comments) + 1)
# With the right content
self.assertTrue('request#123 for package gcc submitted by Admin' in first_select_comment['comment'])
# Second select
self.assertEqual(True, SelectCommand(self.api, staging_b).perform(['puppet']))
second_select_comments = c_api.get_comments(project_name=staging_b)
last_id = sorted(second_select_comments.keys())[-1]
second_select_comment = second_select_comments[last_id]
# The number of comments increased by one
self.assertEqual(len(second_select_comments) - 1, len(first_select_comments))
self.assertNotEqual(second_select_comment['comment'], first_select_comment['comment'])
# The new comments contains new, but not old
self.assertFalse('request#123 for package gcc submitted by Admin' in second_select_comment['comment'])
self.assertTrue('added request#321 for package puppet submitted by Admin' in second_select_comment['comment'])
def test_select_comments(self):
self.wf.setup_rings()
staging_b = self.wf.create_staging('B', freeze=True)
c_api = CommentAPI(self.wf.api.apiurl)
comments = c_api.get_comments(project_name=staging_b.name)
r1 = self.wf.create_submit_request('devel:wine', 'wine')
r2 = self.wf.create_submit_request('devel:gcc', 'gcc')
# First select
self.assertEqual(True, SelectCommand(self.wf.api, staging_b.name).perform(['gcc', 'wine']))
first_select_comments = c_api.get_comments(project_name=staging_b.name)
last_id = sorted(first_select_comments.keys())[-1]
first_select_comment = first_select_comments[last_id]
# Only one comment is added
self.assertEqual(len(first_select_comments), len(comments) + 1)
# With the right content
expected = 'request#{} for package gcc submitted by Admin'.format(r2.reqid)
self.assertTrue(expected in first_select_comment['comment'])
# Second select
r3 = self.wf.create_submit_request('devel:gcc', 'gcc8')
self.assertEqual(True, SelectCommand(self.wf.api, staging_b.name).perform(['gcc8']))
second_select_comments = c_api.get_comments(project_name=staging_b.name)
last_id = sorted(second_select_comments.keys())[-1]
second_select_comment = second_select_comments[last_id]
# The number of comments increased by one
self.assertEqual(len(second_select_comments) - 1, len(first_select_comments))
self.assertNotEqual(second_select_comment['comment'], first_select_comment['comment'])
# The new comments contains new, but not old
self.assertFalse('request#{} for package gcz submitted by Admin'.format(r2.reqid) in second_select_comment['comment'])
self.assertTrue('added request#{} for package gcc8 submitted by Admin'.format(r3.reqid) in second_select_comment['comment'])
def test_select_comments(self):
c_api = CommentAPI(self.api.apiurl)
staging_b = 'openSUSE:Factory:Staging:B'
comments = c_api.get_comments(project_name=staging_b)
# First select
self.assertEqual(True, SelectCommand(self.api).perform(staging_b, ['gcc', 'wine']))
first_select_comments = c_api.get_comments(project_name=staging_b)
last_id = sorted(first_select_comments.keys())[-1]
first_select_comment = first_select_comments[last_id]
# Only one comment is added
self.assertEqual(len(first_select_comments), len(comments) + 1)
# With the right content
self.assertTrue('Request#123 for package gcc submitted by @Admin' in first_select_comment['comment'])
# Second select
self.assertEqual(True, SelectCommand(self.api).perform(staging_b, ['puppet']))
second_select_comments = c_api.get_comments(project_name=staging_b)
last_id = sorted(second_select_comments.keys())[-1]
second_select_comment = second_select_comments[last_id]
# The number of comments remains, but they are different
self.assertEqual(len(second_select_comments), len(first_select_comments))
self.assertNotEqual(second_select_comment['comment'], first_select_comment['comment'])
# The new comments contents both old and new information
self.assertTrue('Request#123 for package gcc submitted by @Admin' in second_select_comment['comment'])
self.assertTrue('Request#321 for package puppet submitted by @Admin' in second_select_comment['comment'])
def test_select_comments(self):
c_api = CommentAPI(self.api.apiurl)
staging_b = 'openSUSE:Factory:Staging:B'
comments = c_api.get_comments(project_name=staging_b)
# First select
self.assertEqual(
True,
SelectCommand(self.api, staging_b).perform(['gcc', 'wine']))
first_select_comments = c_api.get_comments(project_name=staging_b)
last_id = sorted(first_select_comments.keys())[-1]
first_select_comment = first_select_comments[last_id]
# Only one comment is added
self.assertEqual(len(first_select_comments), len(comments) + 1)
# With the right content
self.assertTrue('Request#123 for package gcc submitted by @Admin' in
first_select_comment['comment'])
# Second select
self.assertEqual(
True,
SelectCommand(self.api, staging_b).perform(['puppet']))
second_select_comments = c_api.get_comments(project_name=staging_b)
last_id = sorted(second_select_comments.keys())[-1]
second_select_comment = second_select_comments[last_id]
# The number of comments remains, but they are different
self.assertEqual(len(second_select_comments),
len(first_select_comments))
self.assertNotEqual(second_select_comment['comment'],
first_select_comment['comment'])
# The new comments contents both old and new information
self.assertTrue('Request#123 for package gcc submitted by @Admin' in
second_select_comment['comment'])
self.assertTrue('Request#321 for package puppet submitted by @Admin' in
second_select_comment['comment'])
def remind_comment(apiurl, repeat_age, request_id, project, package=None):
comment_api = CommentAPI(apiurl)
comments = comment_api.get_comments(request_id=request_id)
comment, _ = comment_api.comment_find(comments, BOT_NAME)
if comment:
delta = datetime.utcnow() - comment['when']
if delta.days < repeat_age:
print(' skipping due to previous reminder from {} days ago'.format(delta.days))
return
# Repeat notification so remove old comment.
try:
comment_api.delete(comment['id'])
except HTTPError as e:
if e.code == 403:
# Gracefully skip when previous reminder was by another user.
print(' unable to remove previous reminder')
return
raise e
userids = sorted(maintainers_get(apiurl, project, package))
if len(userids):
users = ['@' + userid for userid in userids]
message = '{}: {}'.format(', '.join(users), REMINDER)
else:
message = REMINDER
print(' ' + message)
message = comment_api.add_marker(message, BOT_NAME)
comment_api.add_comment(request_id=request_id, comment=message)
def remind_comment(apiurl, repeat_age, request_id, project, package=None):
comment_api = CommentAPI(apiurl)
comments = comment_api.get_comments(request_id=request_id)
comment, _ = comment_api.comment_find(comments, BOT_NAME)
if comment:
delta = datetime.utcnow() - comment['when']
if delta.days < repeat_age:
print(
' skipping due to previous reminder from {} days ago'.format(
delta.days))
return
# Repeat notification so remove old comment.
try:
comment_api.delete(comment['id'])
except HTTPError as e:
if e.code == 403:
# Gracefully skip when previous reminder was by another user.
print(' unable to remove previous reminder')
return
raise e
userids = sorted(maintainers_get(apiurl, project, package))
if len(userids):
users = ['@' + userid for userid in userids]
message = '{}: {}'.format(', '.join(users), REMINDER)
else:
message = REMINDER
print(' ' + message)
message = comment_api.add_marker(message, BOT_NAME)
comment_api.add_comment(request_id=request_id, comment=message)
def test_accept_comments(self):
c_api = CommentAPI(self.api.apiurl)
staging_c = 'openSUSE:Factory:Staging:C'
comments = c_api.get_comments(project_name=staging_c)
# Accept staging C (containing apparmor and mariadb)
self.assertEqual(True, AcceptCommand(self.api).perform(staging_c))
# Comments are cleared up
accepted_comments = c_api.get_comments(project_name=staging_c)
self.assertNotEqual(len(comments), 0)
self.assertEqual(len(accepted_comments), 0)
# But the comment was written at some point
self.assertEqual(len(self.obs.comment_bodies), 1)
comment = self.obs.comment_bodies[0]
self.assertTrue('The following packages have been submitted to openSUSE:Factory' in comment)
self.assertTrue('apparmor' in comment)
self.assertTrue('mariadb' in comment)
def check_comment(apiurl, bot, **kwargs):
if not len(kwargs):
return False
api = CommentAPI(apiurl)
comments = api.get_comments(**kwargs)
comment = api.comment_find(comments, bot)[0]
if comment:
return (datetime.utcnow() - comment['when']).total_seconds()
return False
def check_comment(apiurl, bot, **kwargs):
if not len(kwargs):
return False
api = CommentAPI(apiurl)
comments = api.get_comments(**kwargs)
comment = api.comment_find(comments, bot)[0]
if comment:
return (datetime.utcnow() - comment['when']).total_seconds()
return False
class TestAccept(unittest.TestCase):
def setup_vcr(self):
wf = OBSLocal.StagingWorkflow()
wf.setup_rings()
self.c_api = CommentAPI(wf.api.apiurl)
staging_b = wf.create_staging('B', freeze=True)
self.prj = staging_b.name
self.winerq = wf.create_submit_request('devel:wine', 'wine', text='Hallo World')
self.assertEqual(True, SelectCommand(wf.api, self.prj).perform(['wine']))
self.comments = self.c_api.get_comments(project_name=self.prj)
self.assertGreater(len(self.comments), 0)
return wf
def test_accept_comments(self):
wf = self.setup_vcr()
self.assertEqual(True, AcceptCommand(wf.api).perform(self.prj))
# Comments are cleared up
accepted_comments = self.c_api.get_comments(project_name=self.prj)
self.assertEqual(len(accepted_comments), 0)
def test_accept_final_comment(self):
wf = self.setup_vcr()
# snipe out cleanup to see the comments before the final countdown
wf.api.staging_deactivate = MagicMock(return_value=True)
self.assertEqual(True, AcceptCommand(wf.api).perform(self.prj))
comments = self.c_api.get_comments(project_name=self.prj)
self.assertGreater(len(comments), len(self.comments))
# check which id was added
new_id = (set(comments.keys()) - set(self.comments.keys())).pop()
comment = comments[new_id]['comment']
self.assertEqual('Project "{}" accepted. The following packages have been submitted to openSUSE:Factory: wine.'.format(self.prj), comment)
def test_accept_comments(self):
c_api = CommentAPI(self.api.apiurl)
staging_c = 'openSUSE:Factory:Staging:C'
comments = c_api.get_comments(project_name=staging_c)
# Accept staging C (containing apparmor and mariadb)
self.assertEqual(True, AcceptCommand(self.api).perform(staging_c))
# Comments are cleared up
accepted_comments = c_api.get_comments(project_name=staging_c)
self.assertNotEqual(len(comments), 0)
self.assertEqual(len(accepted_comments), 0)
# But the comment was written at some point
self.assertEqual(len(self.obs.comment_bodies), 1)
comment = self.obs.comment_bodies[0]
self.assertTrue(
'The following packages have been submitted to openSUSE:Factory' in
comment)
self.assertTrue('apparmor' in comment)
self.assertTrue('mariadb' in comment)
def create_comments(self, state):
comments = dict()
for source, details in state['check'].items():
rebuild = dateutil.parser.parse(details["rebuild"])
if datetime.now() - rebuild < timedelta(days=2):
self.logger.debug(f"Ignore {source} - problem too recent")
continue
_, _, arch, rpm = source.split('/')
rpm = rpm.split(':')[0]
comments.setdefault(rpm, {})
comments[rpm][arch] = details['problem']
url = makeurl(self.apiurl, ['comments', 'user'])
root = ET.parse(http_GET(url)).getroot()
for comment in root.findall('.//comment'):
if comment.get('project') != self.project:
continue
if comment.get('package') in comments:
continue
self.logger.info("Removing comment for package {}".format(
comment.get('package')))
url = makeurl(self.apiurl, ['comment', comment.get('id')])
http_DELETE(url)
commentapi = CommentAPI(self.apiurl)
MARKER = 'Installcheck'
for package in comments:
newcomment = ''
for arch in sorted(comments[package]):
newcomment += f"\n\n**Installcheck problems for {arch}**\n\n"
for problem in sorted(comments[package][arch]):
newcomment += "+ " + problem + "\n"
newcomment = commentapi.add_marker(newcomment.strip(), MARKER)
oldcomments = commentapi.get_comments(project_name=self.project,
package_name=package)
oldcomment, _ = commentapi.comment_find(oldcomments, MARKER)
if oldcomment and oldcomment['comment'] == newcomment:
continue
if oldcomment:
commentapi.delete(oldcomment['id'])
self.logger.debug("Adding comment to {}/{}".format(
self.project, package))
commentapi.add_comment(project_name=self.project,
package_name=package,
comment=newcomment)
def update_status_comments(self, project, command):
"""
Refresh the status comments, used for notification purposes, based on
the current list of requests. To ensure that all involved users
(and nobody else) get notified, old status comments are deleted and
a new one is created.
:param project: project name
:param command: name of the command to include in the message
"""
# TODO: we need to discuss the best way to keep track of status
# comments. Right now they are marked with an initial markdown
# comment. Maybe a cleaner approach would be to store something
# like 'last_status_comment_id' in the pseudometa. But the current
# OBS API for adding comments doesn't return the id of the created
# comment.
comment_api = CommentAPI(self.apiurl)
comments = comment_api.get_comments(project_name=project)
for comment in comments.values():
# TODO: update the comment removing the user mentions instead of
# deleting the whole comment. But there is currently not call in
# OBS API to update a comment
if comment['comment'].startswith('<!--- osc staging'):
comment_api.delete(comment['id'])
break # There can be only one! (if we keep deleting them)
meta = self.get_prj_pseudometa(project)
lines = ['<!--- osc staging %s --->' % command]
lines.append('The list of requests tracked in %s has changed:\n' %
project)
for req in meta['requests']:
author = req.get('autor', None)
if not author:
# Old style metadata
author = get_request(self.apiurl, str(req['id'])).get_creator()
lines.append(' * Request#%s for package %s submitted by @%s' %
(req['id'], req['package'], author))
msg = '\n'.join(lines)
comment_api.add_comment(project_name=project, comment=msg)
def update_status_comments(self, project, command):
"""
Refresh the status comments, used for notification purposes, based on
the current list of requests. To ensure that all involved users
(and nobody else) get notified, old status comments are deleted and
a new one is created.
:param project: project name
:param command: name of the command to include in the message
"""
# TODO: we need to discuss the best way to keep track of status
# comments. Right now they are marked with an initial markdown
# comment. Maybe a cleaner approach would be to store something
# like 'last_status_comment_id' in the pseudometa. But the current
# OBS API for adding comments doesn't return the id of the created
# comment.
comment_api = CommentAPI(self.apiurl)
comments = comment_api.get_comments(project_name=project)
for comment in comments.values():
# TODO: update the comment removing the user mentions instead of
# deleting the whole comment. But there is currently not call in
# OBS API to update a comment
if comment['comment'].startswith('<!--- osc staging'):
comment_api.delete(comment['id'])
break # There can be only one! (if we keep deleting them)
meta = self.get_prj_pseudometa(project)
lines = ['<!--- osc staging %s --->' % command]
lines.append('The list of requests tracked in %s has changed:\n' % project)
for req in meta['requests']:
author = req.get('autor', None)
if not author:
# Old style metadata
author = get_request(self.apiurl, str(req['id'])).get_creator()
lines.append(' * Request#%s for package %s submitted by @%s' % (req['id'], req['package'], author))
msg = '\n'.join(lines)
comment_api.add_comment(project_name=project, comment=msg)
class InstallChecker(object):
def __init__(self, api, config):
self.api = api
self.config = conf.config[api.project]
self.logger = logging.getLogger('InstallChecker')
self.commentapi = CommentAPI(api.apiurl)
self.arch_whitelist = self.config.get('repo_checker-arch-whitelist')
if self.arch_whitelist:
self.arch_whitelist = set(self.arch_whitelist.split(' '))
self.ring_whitelist = set(
self.config.get('repo_checker-binary-whitelist-ring',
'').split(' '))
self.cycle_packages = self.config.get('repo_checker-allowed-in-cycles')
self.calculate_allowed_cycles()
self.ignore_duplicated = set(
self.config.get('installcheck-ignore-duplicated-binaries',
'').split(' '))
self.ignore_conflicts = set(
self.config.get('installcheck-ignore-conflicts', '').split(' '))
self.ignore_deletes = str2bool(
self.config.get('installcheck-ignore-deletes', 'False'))
def check_required_by(self, fileinfo, provides, requiredby, built_binaries,
comments):
if requiredby.get('name') in built_binaries:
return True
# extract >= and the like
provide = provides.get('dep')
provide = provide.split(' ')[0]
comments.append('{} provides {} required by {}'.format(
fileinfo.find('name').text, provide, requiredby.get('name')))
url = api.makeurl([
'build', api.project, api.cmain_repo, 'x86_64', '_repository',
requiredby.get('name') + '.rpm'
], {'view': 'fileinfo_ext'})
reverse_fileinfo = ET.parse(osc.core.http_GET(url)).getroot()
for require in reverse_fileinfo.findall('requires_ext'):
# extract >= and the like here too
dep = require.get('dep').split(' ')[0]
if dep != provide:
continue
for provided_by in require.findall('providedby'):
if provided_by.get('name') in built_binaries:
continue
comments.append(' also provided by {} -> ignoring'.format(
provided_by.get('name')))
return True
comments.append(
'Error: missing alternative provides for {}'.format(provide))
return False
def check_delete_request(self, req, to_ignore, comments):
package = req.get('package')
if package in to_ignore or self.ignore_deletes:
self.logger.info(
'Delete request for package {} ignored'.format(package))
return True
built_binaries = set([])
file_infos = []
for fileinfo in fileinfo_ext_all(self.api.apiurl, self.api.project,
self.api.cmain_repo, 'x86_64',
package):
built_binaries.add(fileinfo.find('name').text)
file_infos.append(fileinfo)
result = True
for fileinfo in file_infos:
for provides in fileinfo.findall('provides_ext'):
for requiredby in provides.findall('requiredby[@name]'):
result = result and self.check_required_by(
fileinfo, provides, requiredby, built_binaries,
comments)
what_depends_on = depends_on(api.apiurl, api.project, api.cmain_repo,
[package], True)
# filter out dependency on package itself (happens with eg
# java bootstrapping itself with previous build)
if package in what_depends_on:
what_depends_on.remove(package)
if len(what_depends_on):
comments.append(
'{} is still a build requirement of:\n\n- {}'.format(
package, '\n- '.join(sorted(what_depends_on))))
return False
return result
def packages_to_ignore(self, project):
comments = self.commentapi.get_comments(project_name=project)
ignore_re = re.compile(r'^installcheck: ignore (?P<args>.*)$',
re.MULTILINE)
# the last wins, for now we don't care who said it
args = []
for comment in comments.values():
match = ignore_re.search(comment['comment'].replace('\r', ''))
if not match:
continue
args = match.group('args').strip()
# allow space and comma to seperate
args = args.replace(',', ' ').split(' ')
return set(args)
def staging(self, project, force=False):
api = self.api
repository = self.api.cmain_repo
# fetch the build ids at the beginning - mirroring takes a while
buildids = {}
try:
architectures = self.target_archs(project, repository)
except HTTPError as e:
if e.code == 404:
# adi disappear all the time, so don't worry
return False
raise e
all_done = True
for arch in architectures:
pra = '{}/{}/{}'.format(project, repository, arch)
buildid = self.buildid(project, repository, arch)
if not buildid:
self.logger.error('No build ID in {}'.format(pra))
return False
buildids[arch] = buildid
url = self.report_url(project, repository, arch, buildid)
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
check = root.find('check[@name="installcheck"]/state')
if check is not None and check.text != 'pending':
self.logger.info('{} already "{}", ignoring'.format(
pra, check.text))
else:
all_done = False
except HTTPError:
self.logger.info('{} has no status report'.format(pra))
all_done = False
if all_done and not force:
return True
repository_pairs = repository_path_expand(api.apiurl, project,
repository)
result_comment = []
result = True
to_ignore = self.packages_to_ignore(project)
status = api.project_status(project)
if status is None:
self.logger.error('no project status for {}'.format(project))
return False
for req in status.findall('staged_requests/request'):
if req.get('type') == 'delete':
result = result and self.check_delete_request(
req, to_ignore, result_comment)
for arch in architectures:
# hit the first repository in the target project (if existant)
target_pair = None
directories = []
for pair_project, pair_repository in repository_pairs:
# ignore repositories only inherited for config
if repository_arch_state(self.api.apiurl, pair_project,
pair_repository, arch):
if not target_pair and pair_project == api.project:
target_pair = [pair_project, pair_repository]
directories.append(
mirror(self.api.apiurl, pair_project, pair_repository,
arch))
if not api.is_adi_project(project):
# For "leaky" ring packages in letter stagings, where the
# repository setup does not include the target project, that are
# not intended to to have all run-time dependencies satisfied.
whitelist = self.ring_whitelist
else:
whitelist = set()
whitelist |= to_ignore
ignore_conflicts = self.ignore_conflicts | to_ignore
check = self.cycle_check(project, repository, arch)
if not check.success:
self.logger.warning('Cycle check failed')
result_comment.append(check.comment)
result = False
check = self.install_check(directories, arch, whitelist,
ignore_conflicts)
if not check.success:
self.logger.warning('Install check failed')
result_comment.append(check.comment)
result = False
duplicates = duplicated_binaries_in_repo(self.api.apiurl, project,
repository)
# remove white listed duplicates
for arch in list(duplicates):
for binary in self.ignore_duplicated:
duplicates[arch].pop(binary, None)
if not len(duplicates[arch]):
del duplicates[arch]
if len(duplicates):
self.logger.warning('Found duplicated binaries')
result_comment.append(
yaml.dump(duplicates, default_flow_style=False))
result = False
if result:
self.report_state('success', self.gocd_url(), project, repository,
buildids)
else:
result_comment.insert(
0, 'Generated from {}\n'.format(self.gocd_url()))
self.report_state('failure',
self.upload_failure(project, result_comment),
project, repository, buildids)
self.logger.warning('Not accepting {}'.format(project))
return False
return result
def upload_failure(self, project, comment):
print(project, '\n'.join(comment))
url = self.api.makeurl(
['source', 'home:repo-checker', 'reports', project])
osc.core.http_PUT(url, data='\n'.join(comment))
url = self.api.apiurl.replace('api.', 'build.')
return '{}/package/view_file/home:repo-checker/reports/{}'.format(
url, project)
def report_state(self, state, report_url, project, repository, buildids):
architectures = self.target_archs(project, repository)
for arch in architectures:
self.report_pipeline(state, report_url, project, repository, arch,
buildids[arch])
def gocd_url(self):
if not os.environ.get('GO_SERVER_URL'):
# placeholder :)
return 'http://stephan.kulow.org/'
report_url = os.environ.get('GO_SERVER_URL').replace(':8154', '')
return report_url + '/tab/build/detail/{}/{}/{}/{}/{}#tab-console'.format(
os.environ.get('GO_PIPELINE_NAME'),
os.environ.get('GO_PIPELINE_COUNTER'),
os.environ.get('GO_STAGE_NAME'),
os.environ.get('GO_STAGE_COUNTER'), os.environ.get('GO_JOB_NAME'))
def buildid(self, project, repository, architecture):
url = self.api.makeurl(['build', project, repository, architecture],
{'view': 'status'})
root = ET.parse(osc.core.http_GET(url)).getroot()
buildid = root.find('buildid')
if buildid is None:
return False
return buildid.text
def report_url(self, project, repository, architecture, buildid):
return self.api.makeurl([
'status_reports', 'built', project, repository, architecture,
'reports', buildid
])
def report_pipeline(self, state, report_url, project, repository,
architecture, buildid):
url = self.report_url(project, repository, architecture, buildid)
name = 'installcheck'
xml = self.check_xml(report_url, state, name)
try:
osc.core.http_POST(url, data=xml)
except HTTPError:
print('failed to post status to ' + url)
sys.exit(1)
def check_xml(self, url, state, name):
check = ET.Element('check')
if url:
se = ET.SubElement(check, 'url')
se.text = url
se = ET.SubElement(check, 'state')
se.text = state
se = ET.SubElement(check, 'name')
se.text = name
return ET.tostring(check)
def target_archs(self, project, repository):
archs = target_archs(self.api.apiurl, project, repository)
# Check for arch whitelist and use intersection.
if self.arch_whitelist:
archs = list(self.arch_whitelist.intersection(set(archs)))
# Trick to prioritize x86_64.
return sorted(archs, reverse=True)
def install_check(self, directories, arch, whitelist, ignored_conflicts):
self.logger.info('install check: start (whitelist:{})'.format(
','.join(whitelist)))
parts = installcheck(directories, arch, whitelist, ignored_conflicts)
if len(parts):
header = '### [install check & file conflicts for {}]'.format(arch)
return CheckResult(
False,
header + '\n\n' + ('\n' + ('-' * 80) + '\n\n').join(parts))
self.logger.info('install check: passed')
return CheckResult(True, None)
def calculate_allowed_cycles(self):
self.allowed_cycles = []
if self.cycle_packages:
for comma_list in self.cycle_packages.split(';'):
self.allowed_cycles.append(comma_list.split(','))
def cycle_check(self, project, repository, arch):
self.logger.info('cycle check: start %s/%s/%s' %
(project, repository, arch))
comment = []
depinfo = builddepinfo(self.api.apiurl,
project,
repository,
arch,
order=False)
for cycle in depinfo.findall('cycle'):
for package in cycle.findall('package'):
package = package.text
allowed = False
for acycle in self.allowed_cycles:
if package in acycle:
allowed = True
break
if not allowed:
cycled = [p.text for p in cycle.findall('package')]
comment.append('Package {} appears in cycle {}'.format(
package, '/'.join(cycled)))
if len(comment):
# New cycles, post comment.
self.logger.info('cycle check: failed')
return CheckResult(False, '\n'.join(comment) + '\n')
self.logger.info('cycle check: passed')
return CheckResult(True, None)
def project_pseudometa_file_name(self, project, repository):
filename = 'repo_checker'
main_repo = Config.get(self.api.apiurl, project).get('main-repo')
if not main_repo:
filename += '.' + repository
return filename
class OpenQABot(ReviewBot.ReviewBot):
""" check ABI of library packages
"""
def __init__(self, *args, **kwargs):
super(OpenQABot, self).__init__(*args, **kwargs)
self.tgt_repo = {}
self.project_settings = {}
self.api_map = {}
self.bot_name = 'openqa'
self.force = False
self.openqa = None
self.commentapi = CommentAPI(self.apiurl)
def gather_test_builds(self):
for prj, u in self.tgt_repo[self.openqa.baseurl].items():
buildnr = 0
cjob = 0
for j in self.jobs_for_target(u):
# avoid going backwards in job ID
if cjob > int(j['id']):
continue
buildnr = j['settings']['BUILD']
cjob = int(j['id'])
self.update_test_builds[prj] = buildnr
jobs = self.jobs_for_target(u, build=buildnr)
self.openqa_jobs[prj] = jobs
if self.calculate_qa_status(jobs) == QA_INPROGRESS:
self.pending_target_repos.add(prj)
# reimplemention from baseclass
def check_requests(self):
# to be filled by repos of active
self.incident_repos = dict()
self.update_test_builds = {}
self.pending_target_repos = set()
self.openqa_jobs = {}
if self.ibs:
self.check_suse_incidents()
else:
self.check_opensuse_incidents()
# first calculate the latest build number for current jobs
self.gather_test_builds()
super(OpenQABot, self).check_requests()
# now make sure the jobs are for current repo
for prj, u in self.tgt_repo[self.openqa.baseurl].items():
if prj in self.pending_target_repos:
self.logger.debug("Do not trigger for " + prj)
continue
self.trigger_build_for_target(prj, u)
# check a set of repos for their primary checksums
@staticmethod
def calculate_repo_hash(repos, incidents):
m = hashlib.md5()
# if you want to force it, increase this number
m.update(b'b')
for url in repos:
url += '/repodata/repomd.xml'
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
except HTTPError:
raise
cs = root.find(
'.//{http://linux.duke.edu/metadata/repo}data[@type="primary"]/{http://linux.duke.edu/metadata/repo}checksum'
)
m.update(cs.text.encode('utf-8'))
# now add the open incidents
m.update(json.dumps(incidents, sort_keys=True).encode('utf-8'))
digest = m.hexdigest()
open_incidents = sorted(incidents.keys())
if open_incidents:
digest += ':' + ','.join(open_incidents)
return digest
def is_incident_in_testing(self, incident):
# hard coded for now as we only run this code for SUSE Maintenance workflow
project = 'SUSE:Maintenance:{}'.format(incident)
xpath = "(state/@name='review') and (action/source/@project='{}' and action/@type='maintenance_release')".format(
project)
res = osc.core.search(self.apiurl, request=xpath)['request']
# return the one and only (or None)
return res.find('request')
def calculate_incidents(self, incidents):
"""
get incident numbers from SUSE:Maintenance:Test project
returns dict with openQA var name : string with numbers
"""
self.logger.debug("calculate_incidents: {}".format(pformat(incidents)))
l_incidents = []
for kind, prj in incidents.items():
packages = osc.core.meta_get_packagelist(self.apiurl, prj)
incidents = []
# filter out incidents in staging
for incident in packages:
# remove patchinfo. prefix
incident = incident.replace('_', '.').split('.')[1]
req = self.is_incident_in_testing(incident)
# without release request it's in staging
if not req:
continue
# skip kgraft patches from aggregation
req_ = osc.core.Request()
req_.read(req)
src_prjs = {a.src_project for a in req_.actions}
if SUSEUpdate.kgraft_target(self.apiurl, src_prjs.pop()):
self.logger.debug(
"calculate_incidents: Incident is kgraft - {} ".format(
incident))
continue
incidents.append(incident)
l_incidents.append((kind + '_TEST_ISSUES', ','.join(incidents)))
self.logger.debug("Calculate incidents:{}".format(
pformat(l_incidents)))
return l_incidents
def jobs_for_target(self, data, build=None):
settings = data['settings']
values = {
'distri': settings['DISTRI'],
'version': settings['VERSION'],
'arch': settings['ARCH'],
'flavor': settings['FLAVOR'],
'scope': 'relevant',
'latest': '1',
}
if build:
values['build'] = build
else:
values['test'] = data['test']
self.logger.debug("Get jobs: {}".format(pformat(values)))
return self.openqa.openqa_request('GET', 'jobs', values)['jobs']
# we don't know the current BUILD and querying all jobs is too expensive
# so we need to check for one known TEST first
# if that job doesn't contain the proper hash, we trigger a new one
# and then we know the build
def trigger_build_for_target(self, prj, data):
today = date.today().strftime("%Y%m%d")
try:
repohash = self.calculate_repo_hash(
data['repos'], self.incident_repos.get(prj, {}))
except HTTPError as e:
self.logger.debug(
"REPOHASH not calculated with response {}".format(e))
return
buildnr = None
jobs = self.jobs_for_target(data)
for job in jobs:
if job['settings'].get('REPOHASH', '') == repohash:
# take the last in the row
buildnr = job['settings']['BUILD']
self.update_test_builds[prj] = buildnr
# ignore old build numbers, we want a fresh run every day
# to find regressions in the tests and to get data about
# randomly failing tests
if buildnr and buildnr.startswith(today):
return
buildnr = 0
# not found, then check for the next free build nr
for job in jobs:
build = job['settings']['BUILD']
if build and build.startswith(today):
try:
nr = int(build.split('-')[1])
if nr > buildnr:
buildnr = nr
except ValueError:
continue
buildnr = "{!s}-{:d}".format(today, buildnr + 1)
s = data['settings']
# now schedule it for real
if 'incidents' in data.keys():
for x, y in self.calculate_incidents(data['incidents']):
s[x] = y
s['BUILD'] = buildnr
s['REPOHASH'] = repohash
s['_OBSOLETE'] = '1'
self.logger.debug("Prepared: {}".format(pformat(s)))
if not self.dryrun:
try:
self.logger.info("Openqa isos POST {}".format(pformat(s)))
self.openqa.openqa_request('POST', 'isos', data=s, retries=1)
except Exception as e:
self.logger.error(e)
self.update_test_builds[prj] = buildnr
def request_get_openqa_status(self, req):
types = {a.type for a in req.actions}
if 'maintenance_release' not in types:
return [], QA_UNKNOWN
src_prjs = {a.src_project for a in req.actions}
if len(src_prjs) != 1:
raise Exception(
"can't handle maintenance_release from different incidents")
build = src_prjs.pop()
incident_id = build.split(':')[-1]
tgt_prjs = {a.tgt_project for a in req.actions}
jobs = self.openqa_jobs.get(build, [])
qa_status = self.calculate_qa_status(jobs)
if qa_status == QA_UNKNOWN or qa_status == QA_INPROGRESS:
return jobs, qa_status
# check if the repo jobs include the incident
repo_jobs = []
for prj in sorted(tgt_prjs):
repo_settings = self.tgt_repo.get(self.openqa.baseurl, {})
if prj in repo_settings:
repo_jobs += self.openqa_jobs[prj]
for job in repo_jobs:
foundissue = False
for key, value in job['settings'].items():
if key.endswith('_TEST_ISSUES'):
if incident_id in value.split(','):
foundissue = True
if not foundissue:
self.logger.info("Repo job {} not for {} - ignoring".format(
job['id'], incident_id))
return jobs, QA_INPROGRESS
# print(foundissue, incident_id, json.dumps(job['settings'], indent=4))
jobs += repo_jobs
return jobs, self.calculate_qa_status(jobs)
def calculate_qa_status(self, jobs=None):
if not jobs:
return QA_UNKNOWN
j = {}
has_failed = False
in_progress = False
for job in jobs:
if job['clone_id']:
continue
name = job['name']
if name in j and int(job['id']) < int(j[name]['id']):
continue
j[name] = job
if job['state'] not in ('cancelled', 'done'):
in_progress = True
else:
if job['result'] != 'passed' and job['result'] != 'softfailed':
has_failed = True
if not j:
return QA_UNKNOWN
if in_progress:
return QA_INPROGRESS
if has_failed:
return QA_FAILED
return QA_PASSED
# escape markdown
@staticmethod
def emd(str):
return str.replace('_', r'\_')
@staticmethod
def get_step_url(testurl, modulename):
failurl = testurl + '/modules/{!s}/fails'.format(
quote_plus(modulename))
fails = requests.get(failurl).json()
failed_step = fails.get('first_failed_step', 1)
return "[{!s}]({!s}#step/{!s}/{:d})".format(OpenQABot.emd(modulename),
testurl, modulename,
failed_step)
@staticmethod
def job_test_name(job):
return "{!s}@{!s}".format(OpenQABot.emd(job['settings']['TEST']),
OpenQABot.emd(job['settings']['MACHINE']))
def summarize_one_openqa_job(self, job):
testurl = osc.core.makeurl(self.openqa.baseurl,
['tests', str(job['id'])])
if not job['result'] in ['passed', 'failed', 'softfailed']:
rstring = job['result']
if rstring == 'none':
return None
return '\n- [{!s}]({!s}) is {!s}'.format(self.job_test_name(job),
testurl, rstring)
modstrings = []
for module in job['modules']:
if module['result'] != 'failed':
continue
modstrings.append(self.get_step_url(testurl, module['name']))
if modstrings:
return '\n- [{!s}]({!s}) failed in {!s}'.format(
self.job_test_name(job), testurl, ','.join(modstrings))
elif job['result'] == 'failed': # rare case: fail without module fails
return '\n- [{!s}]({!s}) failed'.format(self.job_test_name(job),
testurl)
return ''
def summarize_openqa_jobs(self, jobs):
groups = {}
for job in jobs:
gl = "{!s}@{!s}".format(self.emd(job['group']),
self.emd(job['settings']['FLAVOR']))
if gl not in groups:
groupurl = osc.core.makeurl(
self.openqa.baseurl, ['tests', 'overview'], {
'version': job['settings']['VERSION'],
'groupid': job['group_id'],
'flavor': job['settings']['FLAVOR'],
'distri': job['settings']['DISTRI'],
'build': job['settings']['BUILD'],
})
groups[gl] = {
'title': "__Group [{!s}]({!s})__\n".format(gl, groupurl),
'passed': 0,
'unfinished': 0,
'failed': []
}
job_summary = self.summarize_one_openqa_job(job)
if job_summary is None:
groups[gl]['unfinished'] = groups[gl]['unfinished'] + 1
continue
# None vs ''
if not len(job_summary):
groups[gl]['passed'] = groups[gl]['passed'] + 1
continue
# if there is something to report, hold the request
# TODO: what is this ?
# qa_state = QA_FAILED
# gmsg = groups[gl]
groups[gl]['failed'].append(job_summary)
msg = ''
for group in sorted(groups.keys()):
msg += "\n\n" + groups[group]['title']
infos = []
if groups[group]['passed']:
infos.append("{:d} tests passed".format(
groups[group]['passed']))
if len(groups[group]['failed']):
infos.append("{:d} tests failed".format(
len(groups[group]['failed'])))
if groups[group]['unfinished']:
infos.append("{:d} unfinished tests".format(
groups[group]['unfinished']))
msg += "(" + ', '.join(infos) + ")\n"
for fail in groups[group]['failed']:
msg += fail
return msg.rstrip('\n')
def check_one_request(self, req):
try:
jobs, qa_state = self.request_get_openqa_status(req)
self.logger.debug("request %s state %s", req.reqid, qa_state)
msg = None
if qa_state == QA_UNKNOWN:
incident_id = req.to_xml().findall('.action/source')[0].get(
'project').split(":")[-1]
if not jobs and incident_id not in self.wait_for_build:
msg = "no openQA tests defined"
self.comment_write(state='done',
message=msg,
request=req,
result='accepted')
return True
else:
self.logger.debug("request {} waits for build".format(
req.reqid))
elif qa_state == QA_FAILED or qa_state == QA_PASSED:
if qa_state == QA_PASSED:
msg = "openQA tests passed\n"
result = 'accepted'
ret = True
else:
msg = "openQA tests problematic\n"
result = 'declined'
ret = False
msg += self.summarize_openqa_jobs(jobs)
self.comment_write(state='done',
message=msg,
result=result,
request=req)
return ret
elif qa_state == QA_INPROGRESS:
self.logger.info("request %s still in progress", req.reqid)
else:
raise Exception("unknown QA state %d", qa_state)
except Exception:
import traceback
self.logger.error("unhandled exception in openQA Bot")
self.logger.error(traceback.format_exc())
return None
return
def find_obs_request_comment(self, request_id=None, project_name=None):
"""Return previous comments (should be one)."""
comments = self.commentapi.get_comments(request_id=request_id,
project_name=project_name)
comment, info = self.commentapi.comment_find(comments, self.bot_name)
if comment:
# we only care for two fields
return {'id': comment['id'], 'revision': info['revision']}
return {}
def check_product_arch(self, job, product_prefix, pmap, arch):
need = False
settings = {'VERSION': pmap['version']}
settings['ARCH'] = arch if arch else 'x86_64'
settings['DISTRI'] = pmap.get('distri', 'sle')
issues = pmap.get('issues', {})
issues['OS_TEST_ISSUES'] = issues.get('OS_TEST_ISSUES', product_prefix)
required_issue = pmap.get('required_issue', False)
for key, prefix in issues.items():
# self.logger.debug("KP {} {}".format(key, prefix) + str(job))
channel = prefix
if arch:
channel += arch
if channel in job['channels']:
settings[key] = str(job['id'])
need = True
if required_issue:
if required_issue not in settings:
need = False
if not need:
return []
product_key = product_prefix
if arch:
product_key += arch
update = self.project_settings[product_key]
update.apiurl = self.apiurl
update.logger = self.logger
posts = []
for j in update.settings(
update.maintenance_project + ':' + str(job['id']),
product_key):
if not job.get('openqa_build'):
job['openqa_build'] = update.get_max_revision(job)
if not job.get('openqa_build'):
self.wait_for_build.add(str(job['id']))
return []
self.incident_repos.setdefault(product_key, dict())[str(
job['id'])] = job.get('openqa_build')
j['BUILD'] += '.' + str(job['openqa_build'])
j.update(settings)
# kGraft jobs can have different version
if 'real_version' in j:
j['VERSION'] = j['real_version']
del j['real_version']
posts.append(j)
return posts
def check_product(self, job, product_prefix):
pmap = self.api_map[product_prefix]
posts = []
if 'archs' in pmap:
for arch in pmap['archs']:
posts += self.check_product_arch(job, product_prefix, pmap,
arch)
else:
posts += self.check_product_arch(job, product_prefix, pmap, None)
self.logger.debug("Pmap: {} Posts: {}".format(pmap, posts))
return posts
def incident_openqa_jobs(self, s):
return self.openqa.openqa_request(
'GET', 'jobs', {
'distri': s['DISTRI'],
'version': s['VERSION'],
'arch': s['ARCH'],
'flavor': s['FLAVOR'],
'build': s['BUILD'],
'scope': 'relevant',
'latest': '1'
})['jobs']
# for SUSE we use mesh, for openSUSE we limit the jobs to open release requests
def check_opensuse_incidents(self):
requests = dict() # collecting unique requests
self.wait_for_build = set()
for prj in self.tgt_repo[self.openqa.baseurl].keys():
for r in self.ids_project(prj, 'maintenance_release'):
requests[r.reqid] = r
# to be stored in settings
issues = dict()
for req in sorted(requests.keys()):
req = requests[req]
types = set([a.type for a in req.actions])
if 'maintenance_release' not in types:
continue
src_prjs = set([a.src_project for a in req.actions])
if len(src_prjs) != 1:
raise Exception(
"can't handle maintenance_release from different incidents"
)
build = src_prjs.pop()
incident_id = build.split(':')[-1]
tgt_prjs = set()
for a in req.actions:
prj = a.tgt_project
# ignore e.g. Backports
if prj not in self.project_settings:
continue
issues.setdefault(prj, set()).add(incident_id)
tgt_prjs.add(prj)
self.test_job({
'project': build,
'id': incident_id,
'channels': list(tgt_prjs)
})
for prj in self.tgt_repo[self.openqa.baseurl].keys():
s = self.tgt_repo[self.openqa.baseurl][prj]['settings']
s['OS_TEST_ISSUES'] = ','.join(sorted(issues.get(prj, set())))
def check_suse_incidents(self):
self.wait_for_build = set()
for inc in requests.get(
'https://maintenance.suse.de/api/incident/active/').json():
self.logger.info("Incident number: {}".format(inc))
mesh_job = requests.get(
'https://maintenance.suse.de/api/incident/' + inc).json()
if mesh_job['meta']['state'] in ['final', 'gone']:
continue
# required in mesh_job: project, id, channels
self.test_job(mesh_job['base'])
def test_job(self, mesh_job):
self.logger.debug("Called test_job with: {}".format(mesh_job))
incident_project = str(mesh_job['project'])
try:
comment_info = self.find_obs_request_comment(
project_name=incident_project)
except HTTPError as e:
self.logger.debug("Couldn't load comments - {}".format(e))
return
comment_build = str(comment_info.get('revision', ''))
openqa_posts = []
for prod in self.api_map.keys():
self.logger.debug("{} -- product in apimap".format(prod))
openqa_posts += self.check_product(mesh_job, prod)
openqa_jobs = []
for s in openqa_posts:
if 'skip_job' in s:
self.wait_for_build.add(str(mesh_job['id']))
continue
jobs = self.incident_openqa_jobs(s)
# take the project comment as marker for not posting jobs
if not len(jobs) and comment_build != str(
mesh_job['openqa_build']):
if self.dryrun:
self.logger.info('WOULD POST:{}'.format(
pformat(json.dumps(s, sort_keys=True))))
else:
self.logger.info("Posted: {}".format(
pformat(json.dumps(s, sort_keys=True))))
self.openqa.openqa_request('POST',
'isos',
data=s,
retries=1)
openqa_jobs += self.incident_openqa_jobs(s)
else:
self.logger.info("{} got {}".format(pformat(s), len(jobs)))
openqa_jobs += jobs
self.openqa_jobs[incident_project] = openqa_jobs
if len(openqa_jobs) == 0:
self.logger.debug("No openqa jobs defined")
return
# print openqa_jobs
msg = self.summarize_openqa_jobs(openqa_jobs)
state = 'seen'
result = 'none'
qa_status = self.calculate_qa_status(openqa_jobs)
if qa_status == QA_PASSED:
result = 'accepted'
state = 'done'
if qa_status == QA_FAILED:
result = 'declined'
state = 'done'
self.comment_write(
project=str(incident_project),
state=state,
result=result,
message=msg,
info_extra={'revision': str(mesh_job.get('openqa_build'))})
class ReviewBot(object):
"""
A generic obs request reviewer
Inherit from this class and implement check functions for each action type:
def check_action_<type>(self, req, action):
return (None|True|False)
"""
DEFAULT_REVIEW_MESSAGES = {'accepted': 'ok', 'declined': 'review failed'}
REVIEW_CHOICES = ('normal', 'no', 'accept', 'accept-onpass',
'fallback-onfail', 'fallback-always')
COMMENT_MARKER_REGEX = re.compile(
r'<!-- (?P<bot>[^ ]+) state=(?P<state>[^ ]+)(?: result=(?P<result>[^ ]+))? -->'
)
# map of default config entries
config_defaults = {
# list of tuples (prefix, apiurl, submitrequestprefix)
# set this if the obs instance maps another instance into it's
# namespace
'project_namespace_api_map': [
('openSUSE.org:', 'https://api.opensuse.org', 'obsrq'),
],
}
def __init__(self,
apiurl=None,
dryrun=False,
logger=None,
user=None,
group=None):
self.apiurl = apiurl
self.ibs = apiurl.startswith('https://api.suse.de')
self.dryrun = dryrun
self.logger = logger
self.review_user = user
self.review_group = group
self.requests = []
self.review_messages = ReviewBot.DEFAULT_REVIEW_MESSAGES
self._review_mode = 'normal'
self.fallback_user = None
self.fallback_group = None
self.comment_api = CommentAPI(self.apiurl)
self.bot_name = self.__class__.__name__
self.only_one_action = False
self.request_default_return = None
self.comment_handler = False
self.override_allow = True
self.override_group_key = '{}-override-group'.format(
self.bot_name.lower())
self.request_age_min_default = 0
self.request_age_min_key = '{}-request-age-min'.format(
self.bot_name.lower())
self.lookup = PackageLookup(self.apiurl)
self.load_config()
def _load_config(self, handle=None):
d = self.__class__.config_defaults
y = yaml.safe_load(handle) if handle is not None else {}
return namedtuple('BotConfig', sorted(
d.keys()))(*[y.get(p, d[p]) for p in sorted(d.keys())])
def load_config(self, filename=None):
if filename:
with open(filename, 'r') as fh:
self.config = self._load_config(fh)
else:
self.config = self._load_config()
def has_staging(self, project):
try:
url = osc.core.makeurl(self.apiurl,
('staging', project, 'staging_projects'))
osc.core.http_GET(url)
return True
except HTTPError as e:
if e.code != 404:
self.logger.error('ERROR in URL %s [%s]' % (url, e))
raise
pass
return False
def staging_api(self, project):
# Allow for the Staging subproject to be passed directly from config
# which should be stripped before initializing StagingAPI. This allows
# for NonFree subproject to utilize StagingAPI for main project.
if project.endswith(':Staging'):
project = project[:-8]
if project not in self.staging_apis:
Config.get(self.apiurl, project)
self.staging_apis[project] = StagingAPI(self.apiurl, project)
return self.staging_apis[project]
@property
def review_mode(self):
return self._review_mode
@review_mode.setter
def review_mode(self, value):
if value not in self.REVIEW_CHOICES:
raise Exception("invalid review option: %s" % value)
self._review_mode = value
def set_request_ids(self, ids):
for rqid in ids:
u = osc.core.makeurl(self.apiurl, ['request', rqid],
{'withfullhistory': '1'})
r = osc.core.http_GET(u)
root = ET.parse(r).getroot()
req = osc.core.Request()
req.read(root)
self.requests.append(req)
# function called before requests are reviewed
def prepare_review(self):
pass
def check_requests(self):
self.staging_apis = {}
# give implementations a chance to do something before single requests
self.prepare_review()
return_value = 0
for req in self.requests:
self.logger.info("checking %s" % req.reqid)
self.request = req
with sentry_sdk.configure_scope() as scope:
scope.set_extra('request.id', self.request.reqid)
# XXX: this is a hack. Annotating the request with staging_project.
# OBS itself should provide an API for that but that's currently not the case
# https://github.com/openSUSE/openSUSE-release-tools/pull/2377
if not hasattr(req, 'staging_project'):
staging_project = None
for r in req.reviews:
if r.state == 'new' and r.by_project and ":Staging:" in r.by_project:
staging_project = r.by_project
break
setattr(req, 'staging_project', staging_project)
try:
good = self.check_one_request(req)
except Exception as e:
good = None
import traceback
traceback.print_exc()
return_value = 1
sentry_sdk.capture_exception(e)
if self.review_mode == 'no':
good = None
elif self.review_mode == 'accept':
good = True
if good is None:
self.logger.info("%s ignored" % req.reqid)
elif good:
self._set_review(req, 'accepted')
elif self.review_mode != 'accept-onpass':
self._set_review(req, 'declined')
return return_value
@memoize(session=True)
def request_override_check_users(self, project):
"""Determine users allowed to override review in a comment command."""
config = Config.get(self.apiurl, project)
users = []
group = config.get('staging-group')
if group:
users += group_members(self.apiurl, group)
if self.override_group_key:
override_group = config.get(self.override_group_key)
if override_group:
users += group_members(self.apiurl, override_group)
return users
def request_override_check(self, force=False):
"""Check for a comment command requesting review override."""
if not force and not self.override_allow:
return None
for args, who in self.request_commands('override'):
message = 'overridden by {}'.format(who)
override = args[1] if len(args) >= 2 else 'accept'
if override == 'accept':
self.review_messages['accepted'] = message
return True
if override == 'decline':
self.review_messages['declined'] = message
return False
def request_commands(self,
command,
who_allowed=None,
request=None,
action=None,
include_description=True):
if not request:
request = self.request
if not action:
action = self.action
if not who_allowed:
who_allowed = self.request_override_check_users(action.tgt_project)
comments = self.comment_api.get_comments(request_id=request.reqid)
if include_description:
request_comment = self.comment_api.request_as_comment_dict(request)
comments[request_comment['id']] = request_comment
yield from self.comment_api.command_find(comments, self.review_user,
command, who_allowed)
def _set_review(self, req, state):
doit = self.can_accept_review(req.reqid)
if doit is None:
self.logger.info(
"can't change state, %s does not have the reviewer" %
(req.reqid))
newstate = state
by_user = self.fallback_user
by_group = self.fallback_group
msg = self.review_messages[
state] if state in self.review_messages else state
self.logger.info("%s %s: %s" % (req.reqid, state, msg))
if state == 'declined':
if self.review_mode == 'fallback-onfail':
self.logger.info("%s needs fallback reviewer" % req.reqid)
self.add_review(
req,
by_group=by_group,
by_user=by_user,
msg="Automated review failed. Needs fallback reviewer.")
newstate = 'accepted'
elif self.review_mode == 'fallback-always':
self.add_review(req,
by_group=by_group,
by_user=by_user,
msg='Adding fallback reviewer')
if doit == True:
self.logger.debug("setting %s to %s" % (req.reqid, state))
if not self.dryrun:
try:
osc.core.change_review_state(apiurl=self.apiurl,
reqid=req.reqid,
newstate=newstate,
by_group=self.review_group,
by_user=self.review_user,
message=msg)
except HTTPError as e:
if e.code != 403:
raise e
self.logger.info(
'unable to change review state (likely superseded or revoked)'
)
else:
self.logger.debug("%s review not changed" % (req.reqid))
# allow_duplicate=True should only be used if it makes sense to force a
# re-review in a scenario where the bot adding the review will rerun.
# Normally a declined review will automatically be reopened along with the
# request and any other bot reviews already added will not be touched unless
# the issuing bot is rerun which does not fit normal workflow.
def add_review(self,
req,
by_group=None,
by_user=None,
by_project=None,
by_package=None,
msg=None,
allow_duplicate=False):
query = {'cmd': 'addreview'}
if by_group:
query['by_group'] = by_group
elif by_user:
query['by_user'] = by_user
elif by_project:
query['by_project'] = by_project
if by_package:
query['by_package'] = by_package
else:
raise osc.oscerr.WrongArgs("missing by_*")
for r in req.reviews:
if (r.by_group == by_group and r.by_project == by_project
and r.by_package == by_package and r.by_user == by_user and
# Only duplicate when allow_duplicate and state != new.
(not allow_duplicate or r.state == 'new')):
del query['cmd']
self.logger.debug(
'skipped adding duplicate review for {}'.format('/'.join(
query.values())))
return
u = osc.core.makeurl(self.apiurl, ['request', req.reqid], query)
if self.dryrun:
self.logger.info('POST %s' % u)
return
if self.multiple_actions:
key = request_action_key(self.action)
msg = yaml.dump({key: msg}, default_flow_style=False)
try:
r = osc.core.http_POST(u, data=msg)
except HTTPError as e:
if e.code != 403:
raise e
del query['cmd']
self.logger.info('unable to add review {} with message: {}'.format(
query, msg))
return
code = ET.parse(r).getroot().attrib['code']
if code != 'ok':
raise Exception('non-ok return code: {}'.format(code))
def devel_project_review_add(self,
request,
project,
package,
message='adding devel project review'):
devel_project, devel_package = devel_project_fallback(
self.apiurl, project, package)
if not devel_project:
self.logger.warning('no devel project found for {}/{}'.format(
project, package))
return False
self.add_review(request,
by_project=devel_project,
by_package=devel_package,
msg=message)
return True
def devel_project_review_ensure(self,
request,
project,
package,
message='submitter not devel maintainer'):
if not self.devel_project_review_needed(request, project, package):
self.logger.debug('devel project review not needed')
return True
return self.devel_project_review_add(request, project, package,
message)
def devel_project_review_needed(self, request, project, package):
author = request.get_creator()
maintainers = set(maintainers_get(self.apiurl, project, package))
if author in maintainers:
return False
# Carried over from maintbot, but seems haphazard.
for review in request.reviews:
if review.by_user in maintainers:
return False
return True
def check_one_request(self, req):
"""
check all actions in one request.
calls helper functions for each action type
return None if nothing to do, True to accept, False to reject
"""
if len(req.actions) > 1:
if self.only_one_action:
self.review_messages[
'declined'] = 'Only one action per request supported'
return False
# Will cause added reviews and overall review message to include
# each actions message prefixed by an action key.
self.multiple_actions = True
review_messages_multi = {}
else:
self.multiple_actions = False
# Copy original values to revert changes made to them.
self.review_messages = self.DEFAULT_REVIEW_MESSAGES.copy()
if self.comment_handler is not False:
self.comment_handler_add()
overall = True
for a in req.actions:
if self.multiple_actions:
self.review_messages = self.DEFAULT_REVIEW_MESSAGES.copy()
# Store in-case sub-classes need direct access to original values.
self.action = a
key = request_action_key(a)
with sentry_sdk.configure_scope() as scope:
scope.set_extra('action.key', key)
override = self.request_override_check()
if override is not None:
ret = override
else:
func = getattr(self, self.action_method(a))
ret = func(req, a)
# In the case of multiple actions take the "lowest" result where the
# order from lowest to highest is: False, None, True.
if overall is not False:
if ((overall is True and ret is not True)
or (overall is None and ret is False)):
overall = ret
if self.multiple_actions and ret is not None:
message_key = self.review_message_key(ret)
review_messages_multi[key] = self.review_messages[message_key]
message_key = self.review_message_key(overall)
if self.multiple_actions:
message_combined = yaml.dump(review_messages_multi,
default_flow_style=False)
self.review_messages[message_key] = message_combined
elif type(self.review_messages[message_key]) is dict:
self.review_messages[message_key] = yaml.dump(
self.review_messages[message_key], default_flow_style=False)
return overall
def action_method(self, action):
method_prefix = 'check_action'
method_type = action.type
method_suffix = None
if method_type == 'delete':
method_suffix = 'project'
if action.tgt_package is not None:
method_suffix = 'package'
elif action.tgt_repository is not None:
method_suffix = 'repository'
if method_suffix:
method = '_'.join([method_prefix, method_type, method_suffix])
if hasattr(self, method):
return method
method = '_'.join([method_prefix, method_type])
if hasattr(self, method):
return method
method_type = '_default'
return '_'.join([method_prefix, method_type])
def review_message_key(self, result):
return 'accepted' if result else 'declined'
def check_action_maintenance_incident(self, req, a):
if action_is_patchinfo(a):
self.logger.debug('ignoring patchinfo action')
return True
# Duplicate src_package as tgt_package since prior to assignment to a
# specific incident project there is no target package (odd API). After
# assignment it is still assumed the target will match the source. Since
# the ultimate goal is the tgt_releaseproject the incident is treated
# similar to staging in that the intermediate result is not the final
# and thus the true target project (ex. openSUSE:Maintenance) is not
# used for check_source_submission().
tgt_package = a.src_package
if a.tgt_releaseproject is not None:
suffix = '.' + a.tgt_releaseproject.replace(':', '_')
if tgt_package.endswith(suffix):
tgt_package = tgt_package[:-len(suffix)]
# Note tgt_releaseproject (product) instead of tgt_project (maintenance).
return self.check_source_submission(a.src_project, a.src_package,
a.src_rev, a.tgt_releaseproject,
tgt_package)
def check_action_maintenance_release(self, req, a):
pkgname = a.src_package
if action_is_patchinfo(a):
self.logger.debug('ignoring patchinfo action')
return True
linkpkg = self._get_linktarget_self(a.src_project, pkgname)
if linkpkg is not None:
pkgname = linkpkg
# packages in maintenance have links to the target. Use that
# to find the real package name
(linkprj, linkpkg) = self._get_linktarget(a.src_project, pkgname)
if linkpkg is None or linkprj is None or linkprj != a.tgt_project:
self.logger.warning("%s/%s is not a link to %s" %
(a.src_project, pkgname, a.tgt_project))
return self.check_source_submission(a.src_project, a.src_package,
a.src_rev, a.tgt_project,
a.tgt_package)
else:
pkgname = linkpkg
return self.check_source_submission(a.src_project, a.src_package, None,
a.tgt_project, pkgname)
def check_action_submit(self, req, a):
return self.check_source_submission(a.src_project, a.src_package,
a.src_rev, a.tgt_project,
a.tgt_package)
def check_action__default(self, req, a):
# Disable any comment handler to avoid making a comment even if
# comment_write() is called by another bot wrapping __default().
self.comment_handler_remove()
message = 'unhandled request type {}'.format(a.type)
self.logger.info(message)
self.review_messages['accepted'] += ': ' + message
return self.request_default_return
def check_source_submission(self, src_project, src_package, src_rev,
target_project, target_package):
""" default implemention does nothing """
self.logger.info("%s/%s@%s -> %s/%s" %
(src_project, src_package, src_rev, target_project,
target_package))
return None
@staticmethod
@memoize(session=True)
def _get_sourceinfo(apiurl, project, package, rev=None):
query = {'view': 'info'}
if rev is not None:
query['rev'] = rev
url = osc.core.makeurl(apiurl, ('source', project, package),
query=query)
try:
return ET.parse(osc.core.http_GET(url)).getroot()
except (HTTPError, URLError):
return None
def get_originproject(self, project, package, rev=None):
root = ReviewBot._get_sourceinfo(self.apiurl, project, package, rev)
if root is None:
return None
originproject = root.find('originproject')
if originproject is not None:
return originproject.text
return None
def get_sourceinfo(self, project, package, rev=None):
root = ReviewBot._get_sourceinfo(self.apiurl, project, package, rev)
if root is None:
return None
props = ('package', 'rev', 'vrev', 'srcmd5', 'lsrcmd5', 'verifymd5')
return namedtuple('SourceInfo', props)(*[root.get(p) for p in props])
# TODO: what if there is more than _link?
def _get_linktarget_self(self, src_project, src_package):
""" if it's a link to a package in the same project return the name of the package"""
prj, pkg = self._get_linktarget(src_project, src_package)
if prj is None or prj == src_project:
return pkg
def _get_linktarget(self, src_project, src_package):
query = {}
url = osc.core.makeurl(self.apiurl,
('source', src_project, src_package),
query=query)
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
except HTTPError:
return (None, None)
if root is not None:
linkinfo = root.find("linkinfo")
if linkinfo is not None:
return (linkinfo.get('project'), linkinfo.get('package'))
return (None, None)
def _has_open_review_by(self, root, by_what, reviewer):
states = set([
review.get('state') for review in root.findall('review')
if review.get(by_what) == reviewer
])
if not states:
return None
elif 'new' in states:
return True
return False
def can_accept_review(self, request_id):
"""return True if there is a new review for the specified reviewer"""
states = set()
url = osc.core.makeurl(self.apiurl, ('request', str(request_id)))
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
if self.review_user and self._has_open_review_by(
root, 'by_user', self.review_user):
return True
if self.review_group and self._has_open_review_by(
root, 'by_group', self.review_group):
return True
except HTTPError as e:
print('ERROR in URL %s [%s]' % (url, e))
return False
def set_request_ids_search_review(self):
review = None
if self.review_user:
review = "@by_user='******' and @state='new'" % self.review_user
if self.review_group:
review = osc.core.xpath_join(
review, "@by_group='%s' and @state='new'" % self.review_group)
url = osc.core.makeurl(
self.apiurl, ('search', 'request'), {
'match': "state/@name='review' and review[%s]" % review,
'withfullhistory': 1
})
root = ET.parse(osc.core.http_GET(url)).getroot()
self.requests = []
for request in root.findall('request'):
req = osc.core.Request()
req.read(request)
self.requests.append(req)
# also used by openqabot
def ids_project(self, project, typename):
url = osc.core.makeurl(
self.apiurl, ('search', 'request'), {
'match':
"(state/@name='review' or state/@name='new') and (action/target/@project='%s' and action/@type='%s')"
% (project, typename),
'withfullhistory':
1
})
root = ET.parse(osc.core.http_GET(url)).getroot()
ret = []
for request in root.findall('request'):
req = osc.core.Request()
req.read(request)
ret.append(req)
return ret
def set_request_ids_project(self, project, typename):
self.requests = self.ids_project(project, typename)
def comment_handler_add(self, level=logging.INFO):
"""Add handler to start recording log messages for comment."""
self.comment_handler = CommentFromLogHandler(level)
self.logger.addHandler(self.comment_handler)
def comment_handler_remove(self):
self.logger.removeHandler(self.comment_handler)
def comment_handler_lines_deduplicate(self):
self.comment_handler.lines = list(
OrderedDict.fromkeys(self.comment_handler.lines))
def comment_write(self,
state='done',
result=None,
project=None,
package=None,
request=None,
message=None,
identical=False,
only_replace=False,
info_extra=None,
info_extra_identical=True,
bot_name_suffix=None):
"""Write comment if not similar to previous comment and replace old one.
The state, result, and info_extra (dict) are combined to create the info
that is passed to CommentAPI methods for creating a marker and finding
previous comments. self.bot_name, which defaults to class, will be used
as the primary matching key. When info_extra_identical is set to False
info_extra will not be included when finding previous comments to
compare message against.
A comment from the same bot will be replaced when a new comment is
written. The only_replace flag will restrict to only writing a comment
if a prior one is being replaced. This can be useful for writing a final
comment that indicates a change from previous uncompleted state, but
only makes sense to post if a prior comment was posted.
The project, package, and request variables control where the comment is
placed. If no value is given the default is the request being reviewed.
If no message is provided the content will be extracted from
self.comment_handler.line which is provided by CommentFromLogHandler. To
use this call comment_handler_add() at the point which messages should
start being collected. Alternatively the self.comment_handler setting
may be set to True to automatically set one on each request.
The previous comment body line count is compared to see if too similar
to bother posting another comment which is useful for avoiding
re-posting comments that contain irrelevant minor changes. To force an
exact match use the identical flag to replace any non-identical
comment body.
"""
if project:
kwargs = {'project_name': project}
if package:
kwargs['package_name'] = package
else:
if request is None:
request = self.request
kwargs = {'request_id': request.reqid}
debug_key = '/'.join(kwargs.values())
if message is None:
if not len(self.comment_handler.lines):
self.logger.debug(
'skipping empty comment for {}'.format(debug_key))
return
message = '\n\n'.join(self.comment_handler.lines)
bot_name = self.bot_name
if bot_name_suffix:
bot_name = '::'.join([bot_name, bot_name_suffix])
info = {'state': state, 'result': result}
if info_extra and info_extra_identical:
info.update(info_extra)
comments = self.comment_api.get_comments(**kwargs)
comment, _ = self.comment_api.comment_find(comments, bot_name, info)
if info_extra and not info_extra_identical:
# Add info_extra once comment has already been matched.
info.update(info_extra)
message = self.comment_api.add_marker(message, bot_name, info)
message = self.comment_api.truncate(message.strip())
if (comment is not None and
((
identical and
# Remove marker from comments since handled during comment_find().
self.comment_api.remove_marker(comment['comment'])
== self.comment_api.remove_marker(message)) or
(not identical
and comment['comment'].count('\n') == message.count('\n')))):
# Assume same state/result and number of lines in message is duplicate.
self.logger.debug(
'previous comment too similar on {}'.format(debug_key))
return
if comment is None:
self.logger.debug(
'broadening search to include any state on {}'.format(
debug_key))
comment, _ = self.comment_api.comment_find(comments, bot_name)
if comment is not None:
self.logger.debug(
'removing previous comment on {}'.format(debug_key))
if not self.dryrun:
self.comment_api.delete(comment['id'])
elif only_replace:
self.logger.debug(
'no previous comment to replace on {}'.format(debug_key))
return
self.logger.debug('adding comment to {}: {}'.format(
debug_key, message))
if not self.dryrun:
self.comment_api.add_comment(comment=message, **kwargs)
self.comment_handler_remove()
def _check_matching_srcmd5(self, project, package, rev, history_limit=5):
"""check if factory sources contain the package and revision. check head and history"""
self.logger.debug("checking %s in %s" % (package, project))
try:
osc.core.show_package_meta(self.apiurl, project, package)
except (HTTPError, URLError):
self.logger.debug("new package")
return None
si = self.get_sourceinfo(project, package)
if rev == si.verifymd5:
self.logger.debug("srcmd5 matches")
return True
if history_limit:
self.logger.debug("%s not the latest version, checking history",
rev)
u = osc.core.makeurl(self.apiurl,
['source', project, package, '_history'],
{'limit': history_limit})
try:
r = osc.core.http_GET(u)
except HTTPError as e:
self.logger.debug("package has no history!?")
return None
root = ET.parse(r).getroot()
# we need this complicated construct as obs doesn't honor
# the 'limit' parameter use above for obs interconnect:
# https://github.com/openSUSE/open-build-service/issues/2545
for revision, i in zip(reversed(root.findall('revision')),
count()):
node = revision.find('srcmd5')
if node is None:
continue
self.logger.debug("checking %s" % node.text)
if node.text == rev:
self.logger.debug("got it, rev %s" % revision.get('rev'))
return True
if i == history_limit:
break
self.logger.debug("srcmd5 not found in history either")
return False
def request_age_wait(self,
age_min=None,
request=None,
target_project=None):
if not request:
request = self.request
if not target_project:
target_project = self.action.tgt_project
if age_min is None or isinstance(age_min, str):
key = self.request_age_min_key if age_min is None else age_min
age_min = int(
Config.get(self.apiurl,
target_project).get(key,
self.request_age_min_default))
age = request_age(request).total_seconds()
if age < age_min:
self.logger.info(
'skipping {} of age {:.2f}s since it is younger than {}s'.
format(request.reqid, age, age_min))
return True
return False
class ABIChecker(ReviewBot.ReviewBot):
""" check ABI of library packages
"""
def __init__(self, *args, **kwargs):
ReviewBot.ReviewBot.__init__(self, *args, **kwargs)
self.no_review = False
self.force = False
self.ts = rpm.TransactionSet()
self.ts.setVSFlags(rpm._RPMVSF_NOSIGNATURES)
# reports of source submission
self.reports = []
# textual report summary for use in accept/decline message
# or comments
self.text_summary = ''
self.session = DB.db_session()
self.dblogger = LogToDB(self.session)
self.logger.addFilter(self.dblogger)
self.commentapi = CommentAPI(self.apiurl)
self.current_request = None
def check_source_submission(self, src_project, src_package, src_rev,
dst_project, dst_package):
# happens for maintenance incidents
if dst_project == None and src_package == 'patchinfo':
return None
if dst_project in PROJECT_BLACKLIST:
self.logger.info(PROJECT_BLACKLIST[dst_project])
# self.text_summary += PROJECT_BLACKLIST[dst_project] + "\n"
return True
# default is to accept the review, just leave a note if
# there were problems.
ret = True
if self.has_staging(dst_project):
# if staged we don't look at the request source but what
# is in staging
if self.current_request.staging_project:
src_project = self.current_request.staging_project
src_package = dst_package
src_rev = None
else:
self.logger.debug("request not staged yet")
return None
ReviewBot.ReviewBot.check_source_submission(self, src_project,
src_package, src_rev,
dst_project, dst_package)
report = Report(src_project, src_package, src_rev, dst_project,
dst_package, [], None)
dst_srcinfo = self.get_sourceinfo(dst_project, dst_package)
self.logger.debug('dest sourceinfo %s', pformat(dst_srcinfo))
if dst_srcinfo is None:
msg = "%s/%s seems to be a new package, no need to review" % (
dst_project, dst_package)
self.logger.info(msg)
self.reports.append(report)
return True
src_srcinfo = self.get_sourceinfo(src_project, src_package, src_rev)
self.logger.debug('src sourceinfo %s', pformat(src_srcinfo))
if src_srcinfo is None:
msg = "%s/%s@%s does not exist!? can't check" % (
src_project, src_package, src_rev)
self.logger.error(msg)
self.text_summary += msg + "\n"
self.reports.append(report)
return False
if os.path.exists(UNPACKDIR):
shutil.rmtree(UNPACKDIR)
try:
# compute list of common repos to find out what to compare
myrepos = self.findrepos(src_project, src_srcinfo, dst_project,
dst_srcinfo)
except NoBuildSuccess as e:
self.logger.info(e)
self.text_summary += "**Error**: %s\n" % e
self.reports.append(report)
return False
except NotReadyYet as e:
self.logger.info(e)
self.reports.append(report)
return None
except SourceBroken as e:
self.logger.error(e)
self.text_summary += "**Error**: %s\n" % e
self.reports.append(report)
return False
if not myrepos:
self.text_summary += "**Error**: %s does not build against %s, can't check library ABIs\n\n" % (
src_project, dst_project)
self.logger.info("no matching repos, can't compare")
self.reports.append(report)
return False
# *** beware of nasty maintenance stuff ***
# if the destination is a maintained project we need to
# mangle our comparison target and the repo mapping
try:
originproject, originpackage, origin_srcinfo, new_repo_map = self._maintenance_hack(
dst_project, dst_srcinfo, myrepos)
if originproject is not None:
dst_project = originproject
if originpackage is not None:
dst_package = originpackage
if origin_srcinfo is not None:
dst_srcinfo = origin_srcinfo
if new_repo_map is not None:
myrepos = new_repo_map
except MaintenanceError as e:
self.text_summary += "**Error**: %s\n\n" % e
self.logger.error('%s', e)
self.reports.append(report)
return False
except NoBuildSuccess as e:
self.logger.info(e)
self.text_summary += "**Error**: %s\n" % e
self.reports.append(report)
return False
except NotReadyYet as e:
self.logger.info(e)
self.reports.append(report)
return None
except SourceBroken as e:
self.logger.error(e)
self.text_summary += "**Error**: %s\n" % e
self.reports.append(report)
return False
notes = []
libresults = []
overall = None
missing_debuginfo = []
for mr in myrepos:
try:
dst_libs, dst_libdebug = self.extract(dst_project, dst_package,
dst_srcinfo, mr.dstrepo,
mr.arch)
# nothing to fetch, so no libs
if dst_libs is None:
continue
except DistUrlMismatch as e:
self.logger.error(
"%s/%s %s/%s: %s" %
(dst_project, dst_package, mr.dstrepo, mr.arch, e))
if ret == True: # need to check again
ret = None
continue
except MissingDebugInfo as e:
missing_debuginfo.append(str(e))
ret = False
continue
except FetchError as e:
self.logger.error(e)
if ret == True: # need to check again
ret = None
continue
try:
src_libs, src_libdebug = self.extract(src_project, src_package,
src_srcinfo, mr.srcrepo,
mr.arch)
if src_libs is None:
if dst_libs:
self.text_summary += "*Warning*: the submission does not contain any libs anymore\n\n"
continue
except DistUrlMismatch as e:
self.logger.error(
"%s/%s %s/%s: %s" %
(src_project, src_package, mr.srcrepo, mr.arch, e))
if ret == True: # need to check again
ret = None
continue
except MissingDebugInfo as e:
missing_debuginfo.append(str(e))
ret = False
continue
except FetchError as e:
self.logger.error(e)
if ret == True: # need to check again
ret = None
continue
# create reverse index for aliases in the source project
src_aliases = dict()
for lib in src_libs.keys():
for a in src_libs[lib]:
src_aliases.setdefault(a, set()).add(lib)
# for each library in the destination project check if the same lib
# exists in the source project. If not check the aliases (symlinks)
# to catch soname changes. Generate pairs of matching libraries.
pairs = set()
for lib in dst_libs.keys():
if lib in src_libs:
pairs.add((lib, lib))
else:
self.logger.debug(
"%s not found in submission, checking aliases", lib)
found = False
for a in dst_libs[lib]:
if a in src_aliases:
for l in src_aliases[a]:
pairs.add((lib, l))
found = True
if found == False:
self.text_summary += "*Warning*: %s no longer packaged\n\n" % lib
self.logger.debug("to diff: %s", pformat(pairs))
# for each pair dump and compare the abi
for old, new in pairs:
# abi dump of old lib
old_base = os.path.join(UNPACKDIR, dst_project, dst_package,
mr.dstrepo, mr.arch)
old_dump = os.path.join(CACHEDIR, 'old.dump')
# abi dump of new lib
new_base = os.path.join(UNPACKDIR, src_project, src_package,
mr.srcrepo, mr.arch)
new_dump = os.path.join(CACHEDIR, 'new.dump')
def cleanup():
if os.path.exists(old_dump):
os.unlink(old_dump)
if os.path.exists(new_dump):
os.unlink(new_dump)
cleanup()
# we just need that to pass a name to abi checker
m = so_re.match(old)
htmlreport = 'report-%s-%s-%s-%s-%s-%08x.html' % (
mr.srcrepo, os.path.basename(old), mr.dstrepo,
os.path.basename(new), mr.arch, int(time.time()))
# run abichecker
if m \
and self.run_abi_dumper(old_dump, old_base, old, dst_libdebug[old]) \
and self.run_abi_dumper(new_dump, new_base, new, src_libdebug[new]):
reportfn = os.path.join(CACHEDIR, htmlreport)
r = self.run_abi_checker(m.group(1), old_dump, new_dump,
reportfn)
if r is not None:
self.logger.debug('report saved to %s, compatible: %d',
reportfn, r)
libresults.append(
LibResult(mr.srcrepo,
os.path.basename(old), mr.dstrepo,
os.path.basename(new), mr.arch,
htmlreport, r))
if overall is None:
overall = r
elif overall == True and r == False:
overall = r
else:
self.logger.error('failed to compare %s <> %s' %
(old, new))
self.text_summary += "**Error**: ABI check failed on %s vs %s\n\n" % (
old, new)
if ret == True: # need to check again
ret = None
cleanup()
if missing_debuginfo:
self.text_summary += 'debug information is missing for the following packages, can\'t check:\n<pre>'
self.text_summary += ''.join(missing_debuginfo)
self.text_summary += '</pre>\nplease enable debug info in your project config.\n'
self.reports.append(report._replace(result=overall,
reports=libresults))
# upload reports
if os.path.exists(UNPACKDIR):
shutil.rmtree(UNPACKDIR)
return ret
def _maintenance_hack(self, dst_project, dst_srcinfo, myrepos):
pkg = dst_srcinfo.package
originproject = None
originpackage = None
# find the maintenance project
url = osc.core.makeurl(
self.apiurl, ('search', 'project', 'id'),
"match=(maintenance/maintains/@project='%s'+and+attribute/@name='%s')"
% (dst_project, osc.conf.config['maintenance_attribute']))
root = ET.parse(osc.core.http_GET(url)).getroot()
if root is not None:
node = root.find('project')
if node is not None:
# check if target project is a project link where the
# sources don't actually build (like openSUSE:...:Update). That
# is the case if no update was released yet.
# XXX: TODO: do check for whether the package builds here first
originproject = self.get_originproject(dst_project, pkg)
if originproject is not None:
self.logger.debug("origin project %s", originproject)
url = osc.core.makeurl(self.apiurl,
('build', dst_project, '_result'),
{'package': pkg})
root = ET.parse(osc.core.http_GET(url)).getroot()
alldisabled = True
for node in root.findall('status'):
if node.get('code') != 'disabled':
alldisabled = False
if alldisabled:
self.logger.debug(
"all repos disabled, using originproject %s" %
originproject)
else:
originproject = None
else:
mproject = node.attrib['name']
# packages are only a link to packagename.incidentnr
(linkprj, linkpkg) = self._get_linktarget(dst_project, pkg)
if linkpkg is not None and linkprj == dst_project:
self.logger.debug("%s/%s links to %s" %
(dst_project, pkg, linkpkg))
regex = re.compile(r'.*\.(\d+)$')
m = regex.match(linkpkg)
if m is None:
raise MaintenanceError(
"%s/%s -> %s/%s is not a proper maintenance link (must match /%s/)"
% (dst_project, pkg, linkprj, linkpkg,
regex.pattern))
incident = m.group(1)
self.logger.debug("is maintenance incident %s" %
incident)
originproject = "%s:%s" % (mproject, incident)
originpackage = pkg + '.' + dst_project.replace(
':', '_')
origin_srcinfo = self.get_sourceinfo(
originproject, originpackage)
if origin_srcinfo is None:
raise MaintenanceError(
"%s/%s invalid" %
(originproject, originpackage))
# find the map of maintenance incident repos to destination repos
originrepos = self.findrepos(originproject,
origin_srcinfo,
dst_project, dst_srcinfo)
mapped = dict()
for mr in originrepos:
mapped[(mr.dstrepo, mr.arch)] = mr
self.logger.debug("mapping: %s", pformat(mapped))
# map the repos of the original request to the maintenance incident repos
matchrepos = set()
for mr in myrepos:
if not (mr.dstrepo, mr.arch) in mapped:
# sometimes a previously released maintenance
# update didn't cover all architectures. We can
# only ignore that then.
self.logger.warning(
"couldn't find repo %s/%s in %s/%s" %
(mr.dstrepo, mr.arch, originproject,
originpackage))
continue
matchrepos.add(
MR(mr.srcrepo,
mapped[(mr.dstrepo, mr.arch)].srcrepo,
mr.arch))
myrepos = matchrepos
dst_srcinfo = origin_srcinfo
self.logger.debug("new repo map: %s", pformat(myrepos))
return (originproject, originpackage, dst_srcinfo, myrepos)
def find_abichecker_comment(self, req):
"""Return previous comments (should be one)."""
comments = self.commentapi.get_comments(request_id=req.reqid)
for c in comments.values():
m = comment_marker_re.match(c['comment'])
if m:
return c['id'], m.group('state'), m.group('result')
return None, None, None
def check_one_request(self, req):
self.review_messages = ReviewBot.ReviewBot.DEFAULT_REVIEW_MESSAGES
if self.no_review and not self.force and self.check_request_already_done(
req.reqid):
self.logger.info("skip request %s which is already done",
req.reqid)
# TODO: check if the request was seen before and we
# didn't reach a final state for too long
return None
commentid, state, result = self.find_abichecker_comment(req)
## using comments instead of db would be an options for bots
## that use no db
# if self.no_review:
# if state == 'done':
# self.logger.debug("request %s already done, result: %s"%(req.reqid, result))
# return
self.dblogger.request_id = req.reqid
self.current_request = req
self.reports = []
self.text_summary = ''
try:
ret = ReviewBot.ReviewBot.check_one_request(self, req)
except Exception as e:
import traceback
self.logger.error("unhandled exception in ABI checker")
self.logger.error(traceback.format_exc())
ret = None
result = None
if ret is not None:
state = 'done'
result = 'accepted' if ret else 'declined'
else:
# we probably don't want abichecker to spam here
# FIXME don't delete comment in this case
#if state is None and not self.text_summary:
# self.text_summary = 'abichecker will take a look later'
state = 'seen'
self.save_reports_to_db(req, state, result)
if ret is not None and self.text_summary == '':
# if for some reason save_reports_to_db didn't produce a
# summary we add one
self.text_summary = "ABI checker result: [%s](%s/request/%s)" % (
result, WEB_URL, req.reqid)
if commentid and not self.dryrun:
self.commentapi.delete(commentid)
self.post_comment(req, state, result)
self.review_messages = {
'accepted': self.text_summary,
'declined': self.text_summary
}
if self.no_review:
ret = None
self.dblogger.request_id = None
self.current_request = None
return ret
def check_request_already_done(self, reqid):
try:
request = self.session.query(
DB.Request).filter(DB.Request.id == reqid).one()
if request.state == 'done':
return True
except sqlalchemy.orm.exc.NoResultFound as e:
pass
return False
def save_reports_to_db(self, req, state, result):
try:
request = self.session.query(
DB.Request).filter(DB.Request.id == req.reqid).one()
for i in self.session.query(DB.ABICheck).filter(
DB.ABICheck.request_id == request.id).all():
# yeah, we could be smarter here and update existing reports instead
self.session.delete(i)
self.session.flush()
request.state = state
request.result = result
except sqlalchemy.orm.exc.NoResultFound as e:
request = DB.Request(
id=req.reqid,
state=state,
result=result,
)
self.session.add(request)
self.session.commit()
for r in self.reports:
abicheck = DB.ABICheck(request=request,
src_project=r.src_project,
src_package=r.src_package,
src_rev=r.src_rev,
dst_project=r.dst_project,
dst_package=r.dst_package,
result=r.result)
self.session.add(abicheck)
self.session.commit()
if r.result is None:
continue
elif r.result:
self.text_summary += "Good news from ABI check, "
self.text_summary += "%s seems to be ABI [compatible](%s/request/%s):\n\n" % (
r.dst_package, WEB_URL, req.reqid)
else:
self.text_summary += "Warning: bad news from ABI check, "
self.text_summary += "%s may be ABI [**INCOMPATIBLE**](%s/request/%s):\n\n" % (
r.dst_package, WEB_URL, req.reqid)
for lr in r.reports:
libreport = DB.LibReport(
abicheck=abicheck,
src_repo=lr.src_repo,
src_lib=lr.src_lib,
dst_repo=lr.dst_repo,
dst_lib=lr.dst_lib,
arch=lr.arch,
htmlreport=lr.htmlreport,
result=lr.result,
)
self.session.add(libreport)
self.session.commit()
self.text_summary += "* %s (%s): [%s](%s/report/%d)\n" % (
lr.dst_lib, lr.arch, "compatible" if lr.result else
"***INCOMPATIBLE***", WEB_URL, libreport.id)
self.reports = []
def post_comment(self, req, state, result):
if not self.text_summary:
return
msg = "<!-- abichecker state=%s%s -->\n" % (state, ' result=%s' %
result if result else '')
msg += self.text_summary
self.logger.info("add comment: %s" % msg)
if not self.dryrun:
#self.commentapi.delete_from_where_user(self.review_user, request_id = req.reqid)
self.commentapi.add_comment(request_id=req.reqid, comment=msg)
def run_abi_checker(self, libname, old, new, output):
cmd = [
'abi-compliance-checker', '-lib', libname, '-old', old, '-new',
new, '-report-path', output
]
self.logger.debug(cmd)
r = subprocess.Popen(cmd, close_fds=True, cwd=CACHEDIR).wait()
if not r in (0, 1):
self.logger.error('abi-compliance-checker failed')
# XXX: record error
return None
return r == 0
def run_abi_dumper(self, output, base, filename, debuglib):
cmd = [
'abi-dumper', '-o', output, '-lver',
os.path.basename(filename), '/'.join([base, filename])
]
cmd.append('/'.join([base, debuglib]))
self.logger.debug(cmd)
r = subprocess.Popen(cmd, close_fds=True, cwd=CACHEDIR).wait()
if r != 0:
self.logger.error("failed to dump %s!" % filename)
# XXX: record error
return False
return True
def extract(self, project, package, srcinfo, repo, arch):
# fetch cpio headers
# check file lists for library packages
fetchlist, liblist, debuglist = self.compute_fetchlist(
project, package, srcinfo, repo, arch)
if not fetchlist:
msg = "no libraries found in %s/%s %s/%s" % (project, package,
repo, arch)
self.logger.info(msg)
return None, None
# mtimes in cpio are not the original ones, so we need to fetch
# that separately :-(
mtimes = self._getmtimes(project, package, repo, arch)
self.logger.debug("fetchlist %s", pformat(fetchlist))
self.logger.debug("liblist %s", pformat(liblist))
self.logger.debug("debuglist %s", pformat(debuglist))
debugfiles = debuglist.values()
# fetch binary rpms
downloaded = self.download_files(project, package, repo, arch,
fetchlist, mtimes)
# extract binary rpms
tmpfile = os.path.join(CACHEDIR, "cpio")
for fn in fetchlist:
self.logger.debug("extract %s" % fn)
with open(tmpfile, 'wb') as tmpfd:
if not fn in downloaded:
raise FetchError("%s was not downloaded!" % fn)
self.logger.debug(downloaded[fn])
r = subprocess.call(['rpm2cpio', downloaded[fn]],
stdout=tmpfd,
close_fds=True)
if r != 0:
raise FetchError("failed to extract %s!" % fn)
tmpfd.close()
os.unlink(downloaded[fn])
cpio = CpioRead(tmpfile)
cpio.read()
for ch in cpio:
fn = ch.filename.decode('utf-8')
if fn.startswith('./'): # rpm payload is relative
fn = fn[1:]
self.logger.debug("cpio fn %s", fn)
if not fn in liblist and not fn in debugfiles:
continue
dst = os.path.join(UNPACKDIR, project, package, repo, arch)
dst += fn
if not os.path.exists(os.path.dirname(dst)):
os.makedirs(os.path.dirname(dst))
self.logger.debug("dst %s", dst)
# the filehandle in the cpio archive is private so
# open it again
with open(tmpfile, 'rb') as cpiofh:
cpiofh.seek(ch.dataoff, os.SEEK_SET)
with open(dst, 'wb') as fh:
while True:
buf = cpiofh.read(4096)
if buf is None or buf == b'':
break
fh.write(buf)
os.unlink(tmpfile)
return liblist, debuglist
def download_files(self, project, package, repo, arch, filenames, mtimes):
downloaded = dict()
for fn in filenames:
if not fn in mtimes:
raise FetchError(
"missing mtime information for %s, can't check" % fn)
repodir = os.path.join(DOWNLOADS, package, project, repo)
if not os.path.exists(repodir):
os.makedirs(repodir)
t = os.path.join(repodir, fn)
self._get_binary_file(project, repo, arch, package, fn, t,
mtimes[fn])
downloaded[fn] = t
return downloaded
def _get_binary_file(self, project, repository, arch, package, filename,
target, mtime):
"""Get a binary file from OBS."""
# Used to cache, but dropped as part of python3 migration.
osc.core.get_binary_file(self.apiurl,
project,
repository,
arch,
filename,
package=package,
target_filename=target)
def readRpmHeaderFD(self, fd):
h = None
try:
h = self.ts.hdrFromFdno(fd)
except rpm.error as e:
if str(e) == "public key not available":
print(str(e))
if str(e) == "public key not trusted":
print(str(e))
if str(e) == "error reading package header":
print(str(e))
h = None
return h
def _fetchcpioheaders(self, project, package, repo, arch):
u = osc.core.makeurl(self.apiurl,
['build', project, repo, arch, package],
['view=cpioheaders'])
try:
r = osc.core.http_GET(u)
except HTTPError as e:
raise FetchError('failed to fetch header information: %s' % e)
tmpfile = NamedTemporaryFile(prefix="cpio-", delete=False)
for chunk in r:
tmpfile.write(chunk)
tmpfile.close()
cpio = CpioRead(tmpfile.name)
cpio.read()
rpm_re = re.compile('(.+\.rpm)-[0-9A-Fa-f]{32}$')
for ch in cpio:
# ignore errors
if ch.filename == '.errors':
continue
# the filehandle in the cpio archive is private so
# open it again
with open(tmpfile.name, 'rb') as fh:
fh.seek(ch.dataoff, os.SEEK_SET)
h = self.readRpmHeaderFD(fh)
if h is None:
raise FetchError("failed to read rpm header for %s" %
ch.filename)
m = rpm_re.match(ch.filename.decode('utf-8'))
if m:
yield m.group(1), h
os.unlink(tmpfile.name)
def _getmtimes(self, prj, pkg, repo, arch):
""" returns a dict of filename: mtime """
url = osc.core.makeurl(self.apiurl, ('build', prj, repo, arch, pkg))
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
except HTTPError:
return None
return dict([(node.attrib['filename'], node.attrib['mtime'])
for node in root.findall('binary')])
# modified from repochecker
def _last_build_success(self, src_project, tgt_project, src_package, rev):
"""Return the last build success XML document from OBS."""
try:
query = {
'lastsuccess': 1,
'package': src_package,
'pathproject': tgt_project,
'srcmd5': rev
}
url = osc.core.makeurl(self.apiurl,
('build', src_project, '_result'), query)
return ET.parse(osc.core.http_GET(url)).getroot()
except HTTPError as e:
if e.code != 404:
self.logger.error('ERROR in URL %s [%s]' % (url, e))
raise
pass
return None
def get_buildsuccess_repos(self, src_project, tgt_project, src_package,
rev):
root = self._last_build_success(src_project, tgt_project, src_package,
rev)
if root is None:
return None
# build list of repos as set of (name, arch) tuples
repos = set()
for repo in root.findall('repository'):
name = repo.attrib['name']
for node in repo.findall('arch'):
repos.add((name, node.attrib['arch']))
self.logger.debug("success repos: %s", pformat(repos))
return repos
def get_dstrepos(self, project):
url = osc.core.makeurl(self.apiurl, ('source', project, '_meta'))
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
except HTTPError:
return None
repos = set()
for repo in root.findall('repository'):
name = repo.attrib['name']
if project in REPO_WHITELIST and name not in REPO_WHITELIST[
project]:
continue
for node in repo.findall('arch'):
arch = node.text
if project in ARCH_WHITELIST and arch not in ARCH_WHITELIST[
project]:
continue
if project in ARCH_BLACKLIST and arch in ARCH_BLACKLIST[
project]:
continue
repos.add((name, arch))
return repos
def ensure_settled(self, src_project, src_srcinfo, matchrepos):
""" make sure current build state is final so we're not
tricked with half finished results"""
rmap = dict()
results = osc.core.get_package_results(
self.apiurl,
src_project,
src_srcinfo.package,
repository=[mr.srcrepo for mr in matchrepos],
arch=[mr.arch for mr in matchrepos])
for result in results:
for res, _ in osc.core.result_xml_to_dicts(result):
if not 'package' in res or res[
'package'] != src_srcinfo.package:
continue
rmap[(res['repository'], res['arch'])] = res
for mr in matchrepos:
if not (mr.srcrepo, mr.arch) in rmap:
self.logger.warning("%s/%s had no build success" %
(mr.srcrepo, mr.arch))
raise NotReadyYet(src_project, src_srcinfo.package,
"no result")
if rmap[(mr.srcrepo, mr.arch)]['dirty']:
self.logger.warning("%s/%s dirty" % (mr.srcrepo, mr.arch))
raise NotReadyYet(src_project, src_srcinfo.package, "dirty")
code = rmap[(mr.srcrepo, mr.arch)]['code']
if code == 'broken':
raise SourceBroken(src_project, src_srcinfo.package)
if code != 'succeeded' and code != 'locked' and code != 'excluded':
self.logger.warning("%s/%s not succeeded (%s)" %
(mr.srcrepo, mr.arch, code))
raise NotReadyYet(src_project, src_srcinfo.package, code)
def findrepos(self, src_project, src_srcinfo, dst_project, dst_srcinfo):
# get target repos that had a successful build
dstrepos = self.get_dstrepos(dst_project)
if dstrepos is None:
return None
url = osc.core.makeurl(self.apiurl, ('source', src_project, '_meta'))
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
except HTTPError:
return None
# set of source repo name, target repo name, arch
matchrepos = set()
# XXX: another staging hack
if self.current_request.staging_project:
for node in root.findall("repository[@name='standard']/arch"):
arch = node.text
self.logger.debug('arch %s', arch)
matchrepos.add(MR('standard', 'standard', arch))
else:
for repo in root.findall('repository'):
name = repo.attrib['name']
path = repo.findall('path')
if path is None or len(path) != 1:
self.logger.error("repo %s has more than one path" % name)
continue
prj = path[0].attrib['project']
if prj == 'openSUSE:Tumbleweed':
prj = 'openSUSE:Factory' # XXX: hack
if prj != dst_project:
continue
for node in repo.findall('arch'):
arch = node.text
dstname = path[0].attrib['repository']
if prj == 'openSUSE:Factory' and dstname == 'snapshot':
dstname = 'standard' # XXX: hack
if (dstname, arch) in dstrepos:
matchrepos.add(MR(name, dstname, arch))
if not matchrepos:
return None
else:
self.logger.debug('matched repos %s', pformat(matchrepos))
# make sure it's not dirty
self.ensure_settled(src_project, src_srcinfo, matchrepos)
# now check if all matched repos built successfully
srcrepos = self.get_buildsuccess_repos(src_project, dst_project,
src_srcinfo.package,
src_srcinfo.verifymd5)
if srcrepos is None:
raise NotReadyYet(src_project, src_srcinfo.package,
"no build success")
if not srcrepos:
raise NoBuildSuccess(src_project, src_srcinfo.package,
src_srcinfo.verifymd5)
for mr in matchrepos:
if not (mr.srcrepo, arch) in srcrepos:
self.logger.error("%s/%s had no build success" %
(mr.srcrepo, arch))
raise NoBuildSuccess(src_project, src_srcinfo.package,
src_srcinfo.verifymd5)
return matchrepos
# common with repochecker
def _md5_disturl(self, disturl):
"""Get the md5 from the DISTURL from a RPM file."""
return os.path.basename(disturl).split('-')[0]
def disturl_matches_md5(self, disturl, md5):
if self._md5_disturl(disturl) != md5:
return False
return True
# this is a bit magic. OBS allows to take the disturl md5 from the package
# and query the source info for that. We will then get the verify md5 that
# belongs to that md5.
def disturl_matches(self, disturl, prj, srcinfo):
md5 = self._md5_disturl(disturl)
info = self.get_sourceinfo(prj, srcinfo.package, rev=md5)
self.logger.debug(pformat(srcinfo))
self.logger.debug(pformat(info))
if info.verifymd5 == srcinfo.verifymd5:
return True
return False
def compute_fetchlist(self, prj, pkg, srcinfo, repo, arch):
""" scan binary rpms of the specified repo for libraries.
Returns a set of packages to fetch and the libraries found
"""
self.logger.debug('scanning %s/%s %s/%s' % (prj, pkg, repo, arch))
headers = self._fetchcpioheaders(prj, pkg, repo, arch)
missing_debuginfo = set()
lib_packages = dict() # pkgname -> set(lib file names)
pkgs = dict() # pkgname -> cpiohdr, rpmhdr
lib_aliases = dict()
for rpmfn, h in headers:
# skip src rpm
if h['sourcepackage']:
continue
pkgname = h['name'].decode('utf-8')
if pkgname.endswith('-32bit') or pkgname.endswith('-64bit'):
# -32bit and -64bit packages are just repackaged, so
# we skip them and only check the original one.
continue
self.logger.debug("inspecting %s", pkgname)
if not self.disturl_matches(h['disturl'].decode('utf-8'), prj,
srcinfo):
raise DistUrlMismatch(h['disturl'].decode('utf-8'), srcinfo)
pkgs[pkgname] = (rpmfn, h)
if debugpkg_re.match(pkgname):
continue
for fn, mode, lnk in zip(h['filenames'], h['filemodes'],
h['filelinktos']):
fn = fn.decode('utf-8')
lnk = lnk.decode('utf-8')
if so_re.match(fn):
if S_ISREG(mode):
self.logger.debug('found lib: %s' % fn)
lib_packages.setdefault(pkgname, set()).add(fn)
elif S_ISLNK(mode) and lnk is not None:
alias = os.path.basename(fn)
libname = os.path.basename(lnk)
self.logger.debug('found alias: %s -> %s' %
(alias, libname))
lib_aliases.setdefault(libname, set()).add(alias)
fetchlist = set()
liblist = dict()
debuglist = dict()
# check whether debug info exists for each lib
for pkgname in sorted(lib_packages.keys()):
dpkgname = pkgname + '-debuginfo'
if not dpkgname in pkgs:
missing_debuginfo.add((prj, pkg, repo, arch, pkgname))
continue
# check file list of debuginfo package
rpmfn, h = pkgs[dpkgname]
files = set([f.decode('utf-8') for f in h['filenames']])
ok = True
for lib in lib_packages[pkgname]:
libdebug = '/usr/lib/debug%s.debug' % lib
if not libdebug in files:
# some new format that includes version, release and arch in debuginfo?
# FIXME: version and release are actually the
# one from the main package, sub packages may
# differ. BROKEN RIGHT NOW
# XXX: would have to actually read debuglink
# info to get that right so just guessing
arch = h['arch'].decode('utf-8')
if arch == 'i586':
arch = 'i386'
libdebug = '/usr/lib/debug%s-%s-%s.%s.debug' % (
lib, h['version'].decode('utf-8'),
h['release'].decode('utf-8'), arch)
if not libdebug in files:
missing_debuginfo.add(
(prj, pkg, repo, arch, pkgname, lib))
ok = False
if ok:
fetchlist.add(pkgs[pkgname][0])
fetchlist.add(rpmfn)
liblist.setdefault(lib, set())
debuglist.setdefault(lib, libdebug)
libname = os.path.basename(lib)
if libname in lib_aliases:
liblist[lib] |= lib_aliases[libname]
if missing_debuginfo:
self.logger.error('missing debuginfo: %s' %
pformat(missing_debuginfo))
raise MissingDebugInfo(missing_debuginfo)
return fetchlist, liblist, debuglist
class StagingReport(object):
def __init__(self, api):
self.api = api
self.comment = CommentAPI(api.apiurl)
def _package_url(self, package):
link = '/package/live_build_log/%s/%s/%s/%s'
link = link % (package['project'],
package['package'],
package['repository'],
package['arch'])
text = '[%s](%s)' % (package['arch'], link)
return text
def old_enough(self, _date):
time_delta = datetime.utcnow() - _date
safe_margin = timedelta(hours=MARGIN_HOURS)
return safe_margin <= time_delta
def update_status_comment(self, project, report, force=False, only_replace=False):
report = self.comment.add_marker(report, MARKER)
comments = self.comment.get_comments(project_name=project)
comment, _ = self.comment.comment_find(comments, MARKER)
if comment:
write_comment = (report != comment['comment'] and self.old_enough(comment['when']))
else:
write_comment = not only_replace
if write_comment or force:
if osc.conf.config['debug']:
print('Updating comment')
if comment:
self.comment.delete(comment['id'])
self.comment.add_comment(project_name=project, comment=report)
def _report_broken_packages(self, info):
broken_package_status = info['broken_packages']
# Group packages by name
groups = defaultdict(list)
for package in broken_package_status:
groups[package['package']].append(package)
failing_lines = [
'* Build failed %s (%s)' % (key, ', '.join(self._package_url(p) for p in value))
for key, value in groups.iteritems()
]
report = '\n'.join(failing_lines[:MAX_LINES])
if len(failing_lines) > MAX_LINES:
report += '* and more (%s) ...' % (len(failing_lines) - MAX_LINES)
return report
def report_checks(self, info):
failing_lines, green_lines = [], []
links_state = {}
for check in info['checks']:
links_state.setdefault(check['state'], [])
links_state[check['state']].append('[{}]({})'.format(check['name'], check['url']))
lines = []
failure = False
for state, links in links_state.items():
if len(links) > MAX_LINES:
extra = len(links) - MAX_LINES
links = links[:MAX_LINES]
links.append('and {} more...'.format(extra))
lines.append('- {}'.format(state))
if state != 'success':
lines.extend([' - {}'.format(link) for link in links])
failure = True
else:
lines[-1] += ': {}'.format(', '.join(links))
return '\n'.join(lines).strip(), failure
def report(self, project, aggregate=True, force=False):
info = self.api.project_status(project, aggregate)
# Do not attempt to process projects without staging info, or projects
# in a pending state that will change before settling. This avoids
# intermediate notifications that may end up being spammy and for
# long-lived stagings where checks may be re-triggered multiple times
# and thus enter pending state (not seen on first run) which is not
# useful to report.
if not info or not self.api.project_status_final(info):
return
report_broken_packages = self._report_broken_packages(info)
report_checks, check_failure = self.report_checks(info)
if report_broken_packages or check_failure:
if report_broken_packages:
report_broken_packages = 'Broken:\n\n' + report_broken_packages
if report_checks:
report_checks = 'Checks:\n\n' + report_checks
report = '\n\n'.join((report_broken_packages, report_checks))
report = report.strip()
only_replace = False
else:
report = 'Congratulations! All fine now.'
only_replace = True
self.update_status_comment(project, report, force=force, only_replace=only_replace)
if osc.conf.config['debug']:
print(project)
print('-' * len(project))
print(report)
class OpenQABot(ReviewBot.ReviewBot):
""" check ABI of library packages
"""
def __init__(self, *args, **kwargs):
super(OpenQABot, self).__init__(*args, **kwargs)
self.tgt_repo = {}
self.project_settings = {}
self.api_map = {}
self.force = False
self.openqa = None
self.commentapi = CommentAPI(self.apiurl)
self.update_test_builds = {}
self.pending_target_repos = set()
self.openqa_jobs = {}
def gather_test_builds(self):
for prj, u in self.tgt_repo[self.openqa.baseurl].items():
buildnr = 0
cjob = 0
for j in self.jobs_for_target(u):
# avoid going backwards in job ID
if cjob > int(j['id']):
continue
buildnr = j['settings']['BUILD']
cjob = int(j['id'])
self.update_test_builds[prj] = buildnr
jobs = self.jobs_for_target(u, build=buildnr)
self.openqa_jobs[prj] = jobs
if self.calculate_qa_status(jobs) == QA_INPROGRESS:
self.pending_target_repos.add(prj)
# reimplemention from baseclass
def check_requests(self):
if self.ibs:
self.check_suse_incidents()
# first calculate the latest build number for current jobs
self.gather_test_builds()
started = []
# then check progress on running incidents
for req in self.requests:
jobs = self.request_get_openqa_jobs(req,
incident=True,
test_repo=True)
ret = self.calculate_qa_status(jobs)
if ret != QA_UNKNOWN:
started.append(req)
all_requests = self.requests
self.requests = started
self.logger.debug("check started requests")
super(OpenQABot, self).check_requests()
self.requests = all_requests
skipped_one = False
# now make sure the jobs are for current repo
for prj, u in self.tgt_repo[self.openqa.baseurl].items():
if prj in self.pending_target_repos:
skipped_one = True
continue
self.trigger_build_for_target(prj, u)
# do not schedule new incidents unless we finished
# last wave
if skipped_one:
return
self.logger.debug("Check all requests")
super(OpenQABot, self).check_requests()
# check a set of repos for their primary checksums
@staticmethod
def calculate_repo_hash(repos):
m = md5.new()
# if you want to force it, increase this number
m.update('b')
for url in repos:
url += '/repodata/repomd.xml'
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
except HTTPError:
raise
cs = root.find(
'.//{http://linux.duke.edu/metadata/repo}data[@type="primary"]/{http://linux.duke.edu/metadata/repo}checksum'
)
m.update(cs.text)
return m.hexdigest()
def is_incident_in_testing(self, incident):
# hard coded for now as we only run this code for SUSE Maintenance workflow
project = 'SUSE:Maintenance:{}'.format(incident)
xpath = "(state/@name='review') and (action/source/@project='{}' and action/@type='maintenance_release')".format(
project)
res = osc.core.search(self.apiurl, request=xpath)['request']
# return the one and only (or None)
return res.find('request')
def calculate_incidents(self, incidents):
"""
get incident numbers from SUSE:Maintenance:Test project
returns dict with openQA var name : string with numbers
"""
self.logger.debug("calculate_incidents: {}".format(pformat(incidents)))
l_incidents = []
for kind, prj in incidents.items():
packages = osc.core.meta_get_packagelist(self.apiurl, prj)
incidents = []
# filter out incidents in staging
for incident in packages:
# remove patchinfo. prefix
incident = incident.replace('_', '.').split('.')[1]
req = self.is_incident_in_testing(incident)
# without release request it's in staging
if not req:
continue
# skip kgraft patches from aggregation
req_ = osc.core.Request()
req_.read(req)
src_prjs = {a.src_project for a in req_.actions}
if SUSEUpdate.kgraft_target(self.apiurl, src_prjs.pop()):
self.logger.debug(
"calculate_incidents: Incident is kgraft - {} ".format(
incident))
continue
incidents.append(incident)
l_incidents.append((kind + '_TEST_ISSUES', ','.join(incidents)))
self.logger.debug("Calculate incidents:{}".format(
pformat(l_incidents)))
return l_incidents
def jobs_for_target(self, data, build=None):
settings = data['settings'][0]
values = {
'distri': settings['DISTRI'],
'version': settings['VERSION'],
'arch': settings['ARCH'],
'flavor': settings['FLAVOR'],
'scope': 'relevant',
'latest': '1',
}
if build:
values['build'] = build
else:
values['test'] = data['test']
self.logger.debug("Get jobs: {}".format(pformat(values)))
return self.openqa.openqa_request('GET', 'jobs', values)['jobs']
# we don't know the current BUILD and querying all jobs is too expensive
# so we need to check for one known TEST first
# if that job doesn't contain the proper hash, we trigger a new one
# and then we know the build
def trigger_build_for_target(self, prj, data):
today = date.today().strftime("%Y%m%d")
try:
repohash = self.calculate_repo_hash(data['repos'])
except HTTPError as e:
self.logger.debug(
"REPOHAS not calculated with response {}".format(e))
return
buildnr = None
jobs = self.jobs_for_target(data)
for job in jobs:
if job['settings'].get('REPOHASH', '') == repohash:
# take the last in the row
buildnr = job['settings']['BUILD']
self.update_test_builds[prj] = buildnr
# ignore old build numbers, we want a fresh run every day
# to find regressions in the tests and to get data about
# randomly failing tests
if buildnr and buildnr.startswith(today):
return
buildnr = 0
# not found, then check for the next free build nr
for job in jobs:
build = job['settings']['BUILD']
if build and build.startswith(today):
try:
nr = int(build.split('-')[1])
if nr > buildnr:
buildnr = nr
except ValueError:
continue
buildnr = "{!s}-{:d}".format(today, buildnr + 1)
for s in data['settings']:
# now schedule it for real
if 'incidents' in data.keys():
for x, y in self.calculate_incidents(data['incidents']):
s[x] = y
s['BUILD'] = buildnr
s['REPOHASH'] = repohash
self.logger.debug("Prepared: {}".format(pformat(s)))
if not self.dryrun:
try:
self.logger.info("Openqa isos POST {}".format(pformat(s)))
self.openqa.openqa_request('POST',
'isos',
data=s,
retries=1)
except Exception as e:
self.logger.error(e)
self.update_test_builds[prj] = buildnr
def request_get_openqa_jobs(self, req, incident=True, test_repo=False):
ret = None
types = {a.type for a in req.actions}
if 'maintenance_release' in types:
src_prjs = {a.src_project for a in req.actions}
if len(src_prjs) != 1:
raise Exception(
"can't handle maintenance_release from different incidents"
)
build = src_prjs.pop()
tgt_prjs = {a.tgt_project for a in req.actions}
ret = []
if incident:
ret += self.openqa_jobs[build]
for prj in sorted(tgt_prjs):
repo_settings = self.tgt_repo.get(self.openqa.baseurl, {})
if test_repo and prj in repo_settings:
repo_jobs = self.openqa_jobs[prj]
ret += repo_jobs
return ret
def calculate_qa_status(self, jobs=None):
if not jobs:
return QA_UNKNOWN
j = {}
has_failed = False
in_progress = False
for job in jobs:
if job['clone_id']:
continue
name = job['name']
if name in j and int(job['id']) < int(j[name]['id']):
continue
j[name] = job
if job['state'] not in ('cancelled', 'done'):
in_progress = True
else:
if job['result'] != 'passed' and job['result'] != 'softfailed':
has_failed = True
if not j:
return QA_UNKNOWN
if in_progress:
return QA_INPROGRESS
if has_failed:
return QA_FAILED
return QA_PASSED
def add_comment(self, msg, state, request_id=None, result=None):
if not self.do_comments:
return
comment = "<!-- openqa state={!s}{!s} -->\n".format(
state, ' result={!s}'.format(result) if result else '')
comment += "\n" + msg
info = self.find_obs_request_comment(request_id=request_id)
comment_id = info.get('id', None)
if state == info.get('state', 'missing'):
lines_before = len(info['comment'].split('\n'))
lines_after = len(comment.split('\n'))
if lines_before == lines_after:
self.logger.info(
"not worth the update, previous comment %s is state %s",
comment_id, info['state'])
return
self.logger.info("adding comment to %s, state %s result %s",
request_id, state, result)
self.logger.info("message: %s", msg)
if not self.dryrun:
if comment_id:
self.commentapi.delete(comment_id)
self.commentapi.add_comment(request_id=request_id,
comment=str(comment))
# escape markdown
@staticmethod
def emd(str):
return str.replace('_', r'\_')
@staticmethod
def get_step_url(testurl, modulename):
failurl = testurl + '/modules/{!s}/fails'.format(modulename)
fails = requests.get(failurl).json()
failed_step = fails.get('first_failed_step', 1)
return "[{!s}]({!s}#step/{!s}/{:d})".format(OpenQABot.emd(modulename),
testurl, modulename,
failed_step)
@staticmethod
def job_test_name(job):
return "{!s}@{!s}".format(OpenQABot.emd(job['settings']['TEST']),
OpenQABot.emd(job['settings']['MACHINE']))
def summarize_one_openqa_job(self, job):
testurl = osc.core.makeurl(self.openqa.baseurl,
['tests', str(job['id'])])
if not job['result'] in ['passed', 'failed', 'softfailed']:
rstring = job['result']
if rstring == 'none':
return None
return '\n- [{!s}]({!s}) is {!s}'.format(self.job_test_name(job),
testurl, rstring)
modstrings = []
for module in job['modules']:
if module['result'] != 'failed':
continue
modstrings.append(self.get_step_url(testurl, module['name']))
if modstrings:
return '\n- [{!s}]({!s}) failed in {!s}'.format(
self.job_test_name(job), testurl, ','.join(modstrings))
elif job['result'] == 'failed': # rare case: fail without module fails
return '\n- [{!s}]({!s}) failed'.format(self.job_test_name(job),
testurl)
return ''
def summarize_openqa_jobs(self, jobs):
groups = {}
for job in jobs:
gl = "{!s}@{!s}".format(self.emd(job['group']),
self.emd(job['settings']['FLAVOR']))
if gl not in groups:
groupurl = osc.core.makeurl(
self.openqa.baseurl, ['tests', 'overview'], {
'version': job['settings']['VERSION'],
'groupid': job['group_id'],
'flavor': job['settings']['FLAVOR'],
'distri': job['settings']['DISTRI'],
'build': job['settings']['BUILD'],
})
groups[gl] = {
'title': "__Group [{!s}]({!s})__\n".format(gl, groupurl),
'passed': 0,
'unfinished': 0,
'failed': []
}
job_summary = self.summarize_one_openqa_job(job)
if job_summary is None:
groups[gl]['unfinished'] = groups[gl]['unfinished'] + 1
continue
# None vs ''
if not len(job_summary):
groups[gl]['passed'] = groups[gl]['passed'] + 1
continue
# if there is something to report, hold the request
# TODO: what is this ?
# qa_state = QA_FAILED
# gmsg = groups[gl]
groups[gl]['failed'].append(job_summary)
msg = ''
for group in sorted(groups.keys()):
msg += "\n\n" + groups[group]['title']
infos = []
if groups[group]['passed']:
infos.append("{:d} tests passed".format(
groups[group]['passed']))
if len(groups[group]['failed']):
infos.append("{:d} tests failed".format(
len(groups[group]['failed'])))
if groups[group]['unfinished']:
infos.append("{:d} unfinished tests".format(
groups[group]['unfinished']))
msg += "(" + ', '.join(infos) + ")\n"
for fail in groups[group]['failed']:
msg += fail
return msg.rstrip('\n')
def check_one_request(self, req):
ret = None
try:
jobs = self.request_get_openqa_jobs(req)
qa_state = self.calculate_qa_status(jobs)
self.logger.debug("request %s state %s", req.reqid, qa_state)
msg = None
if self.force or qa_state == QA_UNKNOWN:
ret = super(OpenQABot, self).check_one_request(req)
jobs = self.request_get_openqa_jobs(req)
if self.force:
# make sure to delete previous comments if we're forcing
info = self.find_obs_request_comment(request_id=req.reqid)
if 'id' in info:
self.logger.debug("deleting old comment %s",
info['id'])
if not self.dryrun:
self.commentapi.delete(info['id'])
if jobs:
# no notification until the result is done
osc.core.change_review_state(
self.apiurl,
req.reqid,
newstate='new',
by_group=self.review_group,
by_user=self.review_user,
message='now testing in openQA')
else:
msg = "no openQA tests defined"
self.add_comment(msg,
'done',
request_id=req.reqid,
result='accepted')
ret = True
elif qa_state == QA_FAILED or qa_state == QA_PASSED:
# don't take test repo results into the calculation of total
# this is for humans to decide which incident broke the test repo
jobs += self.request_get_openqa_jobs(req,
incident=False,
test_repo=True)
if self.calculate_qa_status(jobs) == QA_INPROGRESS:
self.logger.info(
"incident tests for request %s are done, but need to wait for test repo",
req.reqid)
return
if qa_state == QA_PASSED:
msg = "openQA tests passed\n"
result = 'accepted'
ret = True
else:
msg = "openQA tests problematic\n"
result = 'declined'
ret = False
msg += self.summarize_openqa_jobs(jobs)
self.add_comment(msg,
'done',
result=result,
request_id=req.reqid)
elif qa_state == QA_INPROGRESS:
self.logger.info("request %s still in progress", req.reqid)
else:
raise Exception("unknown QA state %d", qa_state)
except Exception:
import traceback
self.logger.error("unhandled exception in openQA Bot")
self.logger.error(traceback.format_exc())
ret = None
return ret
def find_obs_request_comment(self, request_id=None, project_name=None):
"""Return previous comments (should be one)."""
if self.do_comments:
comments = self.commentapi.get_comments(request_id=request_id,
project_name=project_name)
for c in comments.values():
m = comment_marker_re.match(c['comment'])
if m:
return {
'id': c['id'],
'state': m.group('state'),
'result': m.group('result'),
'comment': c['comment'],
'revision': m.group('revision')
}
return {}
def check_product(self, job, product_prefix):
pmap = self.api_map[product_prefix]
posts = []
for arch in pmap['archs']:
need = False
settings = {'VERSION': pmap['version'], 'ARCH': arch}
settings[
'DISTRI'] = 'sle' if 'distri' not in pmap else pmap['distri']
issues = pmap.get('issues', {})
issues['OS_TEST_ISSUES'] = issues.get('OS_TEST_ISSUES',
product_prefix)
required_issue = pmap.get('required_issue', False)
for key, prefix in issues.items():
self.logger.debug("{} {}".format(key, prefix))
if prefix + arch in job['channels']:
settings[key] = str(job['id'])
need = True
if required_issue:
if required_issue not in settings:
need = False
if need:
update = self.project_settings[product_prefix + arch]
update.apiurl = self.apiurl
update.logger = self.logger
for j in update.settings(
update.maintenance_project + ':' + str(job['id']),
product_prefix + arch, []):
if not job.get('openqa_build'):
job['openqa_build'] = update.get_max_revision(job)
if not job.get('openqa_build'):
return []
j['BUILD'] += '.' + str(job['openqa_build'])
j.update(settings)
# kGraft jobs can have different version
if 'real_version' in j:
j['VERSION'] = j['real_version']
del j['real_version']
posts.append(j)
self.logger.debug("Pmap: {} Posts: {}".format(pmap, posts))
return posts
def incident_openqa_jobs(self, s):
return self.openqa.openqa_request(
'GET', 'jobs', {
'distri': s['DISTRI'],
'version': s['VERSION'],
'arch': s['ARCH'],
'flavor': s['FLAVOR'],
'build': s['BUILD'],
'scope': 'relevant',
'latest': '1'
})['jobs']
def check_suse_incidents(self):
for inc in requests.get(
'https://maintenance.suse.de/api/incident/active/').json():
self.logger.info("Incident number: {}".format(inc))
job = requests.get('https://maintenance.suse.de/api/incident/' +
inc).json()
if job['meta']['state'] in ['final', 'gone']:
continue
# required in job: project, id, channels
self.test_job(job['base'])
def test_job(self, job):
self.logger.debug("Called test_job with: {}".format(job))
incident_project = str(job['project'])
try:
comment_info = self.find_obs_request_comment(
project_name=incident_project)
except HTTPError as e:
self.logger.debug("Couldn't loaadd comments - {}".format(e))
return
comment_id = comment_info.get('id', None)
comment_build = str(comment_info.get('revision', ''))
openqa_posts = []
for prod in self.api_map.keys():
self.logger.debug("{} -- product in apimap".format(prod))
openqa_posts += self.check_product(job, prod)
openqa_jobs = []
for s in openqa_posts:
jobs = self.incident_openqa_jobs(s)
# take the project comment as marker for not posting jobs
if not len(jobs) and comment_build != str(job['openqa_build']):
if self.dryrun:
self.logger.info('WOULD POST:{}'.format(
pformat(json.dumps(s, sort_keys=True))))
else:
self.logger.info("Posted: {}".format(
pformat(json.dumps(s, sort_keys=True))))
self.openqa.openqa_request('POST',
'isos',
data=s,
retries=1)
openqa_jobs += self.incident_openqa_jobs(s)
else:
self.logger.info("{} got {}".format(pformat(s), len(jobs)))
openqa_jobs += jobs
self.openqa_jobs[incident_project] = openqa_jobs
if len(openqa_jobs) == 0:
self.logger.debug("No openqa jobs defined")
return
# print openqa_jobs
msg = self.summarize_openqa_jobs(openqa_jobs)
state = 'seen'
result = 'none'
qa_status = self.calculate_qa_status(openqa_jobs)
if qa_status == QA_PASSED:
result = 'accepted'
state = 'done'
if qa_status == QA_FAILED:
result = 'declined'
state = 'done'
comment = "<!-- openqa state={!s} result={!s} revision={!s} -->\n".format(
state, result, job.get('openqa_build'))
comment += msg
if comment_id and state != 'done':
self.logger.info("%s is already commented, wait until done",
incident_project)
return
if comment_info.get('comment',
'').rstrip('\n') == comment.rstrip('\n'):
self.logger.info("%s comment did not change", incident_project)
return
self.logger.info("adding comment to %s, state %s", incident_project,
state)
if not self.dryrun:
if comment_id:
self.logger.debug("delete comment: {}".format(comment_id))
self.commentapi.delete(comment_id)
self.commentapi.add_comment(project_name=str(incident_project),
comment=str(comment))
class TestCommentOBS(OBSLocal.TestCase):
def setUp(self):
super(TestCommentOBS, self).setUp()
self.wf = OBSLocal.FactoryWorkflow()
self.wf.create_user('factory-auto')
self.wf.create_user('repo-checker')
self.wf.create_user('staging-bot')
self.wf.create_group('factory-staging', ['staging-bot'])
self.wf.create_project(PROJECT,
maintainer={'groups': ['factory-staging']})
self.api = CommentAPI(self.apiurl)
# Ensure different test runs operate in unique namespace.
self.bot = '::'.join([type(self).__name__, str(random.getrandbits(8))])
def tearDown(self):
self.osc_user('Admin')
del self.wf
def test_basic(self):
self.osc_user('staging-bot')
self.assertFalse(self.comments_filtered(self.bot)[0])
self.assertTrue(
self.api.add_comment(project_name=PROJECT,
comment=self.api.add_marker(
COMMENT, self.bot)))
comment, _ = self.comments_filtered(self.bot)
self.assertTrue(comment)
self.assertTrue(self.api.delete(comment['id']))
self.assertFalse(self.comments_filtered(self.bot)[0])
def test_delete_nested(self):
self.osc_user('staging-bot')
comment_marked = self.api.add_marker(COMMENT, self.bot)
# Allow for existing comments by basing assertion on delta from initial count.
comment_count = len(self.api.get_comments(project_name=PROJECT))
self.assertFalse(self.comments_filtered(self.bot)[0])
self.assertTrue(
self.api.add_comment(project_name=PROJECT, comment=comment_marked))
comment, _ = self.comments_filtered(self.bot)
self.assertTrue(comment)
for i in range(0, 3):
self.assertTrue(
self.api.add_comment(project_name=PROJECT,
comment=comment_marked,
parent_id=comment['id']))
comments = self.api.get_comments(project_name=PROJECT)
parented_count = 0
for comment in comments.values():
if comment['parent']:
parented_count += 1
self.assertEqual(parented_count, 3)
self.assertTrue(len(comments) == comment_count + 4)
self.api.delete_from(project_name=PROJECT)
self.assertFalse(len(self.api.get_comments(project_name=PROJECT)))
def test_delete_batch(self):
users = ['factory-auto', 'repo-checker', 'staging-bot']
for user in users:
self.osc_user(user)
print('logged in as ', user)
bot = '::'.join([self.bot, user])
comment = self.api.add_marker(COMMENT, bot)
self.assertFalse(self.comments_filtered(bot)[0])
self.assertTrue(
self.api.add_comment(project_name=PROJECT, comment=comment))
self.assertTrue(self.comments_filtered(bot)[0])
# Allow for existing comments by basing assertion on delta from initial count.
comment_count = len(self.api.get_comments(project_name=PROJECT))
self.assertTrue(comment_count >= len(users))
self.api.delete_from_where_user(users[0], project_name=PROJECT)
self.assertTrue(
len(self.api.get_comments(project_name=PROJECT)) == comment_count -
1)
self.api.delete_from(project_name=PROJECT)
self.assertFalse(len(self.api.get_comments(project_name=PROJECT)))
def comments_filtered(self, bot):
comments = self.api.get_comments(project_name=PROJECT)
return self.api.comment_find(comments, bot)
def prepare_review(self):
# Reset for request batch.
self.requests_map = {}
self.groups = {}
self.groups_build = {}
# Manipulated in ensure_group().
self.group = None
self.mirrored = set()
# Stores parsed install_check() results grouped by package.
self.package_results = {}
# Look for requests of interest and group by staging.
skip_build = set()
for request in self.requests:
# Only interesting if request is staged.
group = request_staged(request)
if not group:
self.logger.debug('{}: not staged'.format(request.reqid))
continue
if self.limit_group and group != self.limit_group:
continue
# Only interested if group has completed building.
api = self.staging_api(request.actions[0].tgt_project)
status = api.project_status(group, True)
# Corrupted requests may reference non-existent projects and will
# thus return a None status which should be considered not ready.
if not status or str(
status['overall_state']) not in ('testing', 'review',
'acceptable'):
# Not in a "ready" state.
openQA_only = False # Not relevant so set to False.
if status and str(status['overall_state']) == 'failed':
# Exception to the rule is openQA only in failed state.
openQA_only = True
for project in api.project_status_walk(status):
if len(project['broken_packages']):
# Broken packages so not just openQA.
openQA_only = False
break
if not self.force and not openQA_only:
self.logger.debug('{}: {} not ready'.format(
request.reqid, group))
continue
# Only interested if request is in consistent state.
selected = api.project_status_requests('selected')
if request.reqid not in selected:
self.logger.debug('{}: inconsistent state'.format(
request.reqid))
if group not in self.groups_build:
# Generate build hash based on hashes from relevant projects.
builds = []
for staging in api.staging_walk(group):
builds.append(
ET.fromstringlist(
show_results_meta(self.apiurl,
staging,
multibuild=True,
repository=['standard'
])).get('state'))
builds.append(
ET.fromstringlist(
show_results_meta(self.apiurl,
api.project,
multibuild=True,
repository=['standard'
])).get('state'))
# Include meta revision for config changes (like whitelist).
builds.append(str(api.get_prj_meta_revision(group)))
self.groups_build[group] = hashlib.sha1(
''.join(builds)).hexdigest()[:7]
# Determine if build has changed since last comment.
comment_api = CommentAPI(api.apiurl)
comments = comment_api.get_comments(project_name=group)
_, info = comment_api.comment_find(comments, self.bot_name)
if info and self.groups_build[group] == info.get('build'):
skip_build.add(group)
if not self.force and group in skip_build:
self.logger.debug('{}: {} build unchanged'.format(
request.reqid, group))
continue
self.requests_map[int(request.reqid)] = group
requests = self.groups.get(group, [])
requests.append(request)
self.groups[group] = requests
self.logger.debug('{}: {} ready'.format(request.reqid, group))
# Filter out undesirable requests and ensure requests are ordered
# together with group for efficiency.
count_before = len(self.requests)
self.requests = []
for group, requests in sorted(self.groups.items()):
self.requests.extend(requests)
self.logger.debug('requests: {} skipped, {} queued'.format(
count_before - len(self.requests), len(self.requests)))
class StagingReport(object):
def __init__(self, api):
self.api = api
self.comment = CommentAPI(api.apiurl)
def _package_url(self, package):
link = '/package/live_build_log/%s/%s/%s/%s'
link = link % (package.get('project'), package.get('package'),
package.get('repository'), package.get('arch'))
text = '[%s](%s)' % (package.get('arch'), link)
return text
def old_enough(self, _date):
time_delta = datetime.utcnow() - _date
safe_margin = timedelta(hours=MARGIN_HOURS)
return safe_margin <= time_delta
def update_status_comment(self,
project,
report,
force=False,
only_replace=False):
report = self.comment.add_marker(report, MARKER)
comments = self.comment.get_comments(project_name=project)
comment, _ = self.comment.comment_find(comments, MARKER)
if comment:
write_comment = (report != comment['comment']
and self.old_enough(comment['when']))
else:
write_comment = not only_replace
if write_comment or force:
if osc.conf.config['debug']:
print('Updating comment')
if comment:
self.comment.delete(comment['id'])
self.comment.add_comment(project_name=project, comment=report)
def _report_broken_packages(self, info):
# Group packages by name
groups = defaultdict(list)
for package in info.findall('broken_packages/package'):
groups[package.get('package')].append(package)
failing_lines = [
'* Build failed %s (%s)' %
(key, ', '.join(self._package_url(p) for p in value))
for key, value in groups.items()
]
report = '\n'.join(failing_lines[:MAX_LINES])
if len(failing_lines) > MAX_LINES:
report += '* and more (%s) ...' % (len(failing_lines) - MAX_LINES)
return report
def report_checks(self, info):
links_state = {}
for check in info.findall('checks/check'):
state = check.find('state').text
links_state.setdefault(state, [])
links_state[state].append('[{}]({})'.format(
check.get('name'),
check.find('url').text))
lines = []
failure = False
for state, links in links_state.items():
if len(links) > MAX_LINES:
extra = len(links) - MAX_LINES
links = links[:MAX_LINES]
links.append('and {} more...'.format(extra))
lines.append('- {}'.format(state))
if state != 'success':
lines.extend([' - {}'.format(link) for link in links])
failure = True
else:
lines[-1] += ': {}'.format(', '.join(links))
return '\n'.join(lines).strip(), failure
def report(self, project, force=False):
info = self.api.project_status(project)
# Do not attempt to process projects without staging info, or projects
# in a pending state that will change before settling. This avoids
# intermediate notifications that may end up being spammy and for
# long-lived stagings where checks may be re-triggered multiple times
# and thus enter pending state (not seen on first run) which is not
# useful to report.
if info is None or not self.api.project_status_final(info):
return
report_broken_packages = self._report_broken_packages(info)
report_checks, check_failure = self.report_checks(info)
if report_broken_packages or check_failure:
if report_broken_packages:
report_broken_packages = 'Broken:\n\n' + report_broken_packages
if report_checks:
report_checks = 'Checks:\n\n' + report_checks
report = '\n\n'.join((report_broken_packages, report_checks))
report = report.strip()
only_replace = False
else:
report = 'Congratulations! All fine now.'
only_replace = True
report = self.cc_list(project, info) + report
self.update_status_comment(project,
report,
force=force,
only_replace=only_replace)
if osc.conf.config['debug']:
print(project)
print('-' * len(project))
print(report)
def cc_list(self, project, info):
if not self.api.is_adi_project(project):
return ""
ccs = set()
for req in info.findall('staged_requests/request'):
ccs.add("@" + req.get('creator'))
str = "Submitters: " + " ".join(sorted(list(ccs))) + "\n\n"
return str
class InstallChecker(object):
def __init__(self, api, config):
self.api = api
self.config = conf.config[api.project]
self.logger = logging.getLogger('InstallChecker')
self.commentapi = CommentAPI(api.apiurl)
self.arch_whitelist = self.config.get('repo_checker-arch-whitelist')
if self.arch_whitelist:
self.arch_whitelist = set(self.arch_whitelist.split(' '))
self.ring_whitelist = set(self.config.get('repo_checker-binary-whitelist-ring', '').split(' '))
self.cycle_packages = self.config.get('repo_checker-allowed-in-cycles')
self.calculate_allowed_cycles()
self.existing_problems = self.binary_list_existing_problem(api.project, api.cmain_repo)
def check_required_by(self, fileinfo, provides, requiredby, built_binaries, comments):
if requiredby.get('name') in built_binaries:
return True
# extract >= and the like
provide = provides.get('dep')
provide = provide.split(' ')[0]
comments.append('{} provides {} required by {}'.format(fileinfo.find('name').text, provide, requiredby.get('name')))
url = api.makeurl(['build', api.project, api.cmain_repo, 'x86_64', '_repository', requiredby.get('name') + '.rpm'],
{'view': 'fileinfo_ext'})
reverse_fileinfo = ET.parse(osc.core.http_GET(url)).getroot()
for require in reverse_fileinfo.findall('requires_ext'):
# extract >= and the like here too
dep = require.get('dep').split(' ')[0]
if dep != provide:
continue
for provided_by in require.findall('providedby'):
if provided_by.get('name') in built_binaries:
continue
comments.append(' also provided by {} -> ignoring'.format(provided_by.get('name')))
return True
comments.append('Error: missing alternative provides for {}'.format(provide))
return False
def check_delete_request(self, req, to_ignore, comments):
package = req['package']
if package in to_ignore:
self.logger.info('Delete request for package {} ignored'.format(package))
return True
built_binaries = set([])
file_infos = []
for fileinfo in fileinfo_ext_all(self.api.apiurl, self.api.project, self.api.cmain_repo, 'x86_64', package):
built_binaries.add(fileinfo.find('name').text)
file_infos.append(fileinfo)
result = True
for fileinfo in file_infos:
for provides in fileinfo.findall('provides_ext'):
for requiredby in provides.findall('requiredby[@name]'):
result = result and self.check_required_by(fileinfo, provides, requiredby, built_binaries, comments)
what_depends_on = depends_on(api.apiurl, api.project, api.cmain_repo, [package], True)
# filter out dependency on package itself (happens with eg
# java bootstrapping itself with previous build)
if package in what_depends_on:
what_depends_on.remove(package)
if len(what_depends_on):
comments.append('{} is still a build requirement of:\n\n- {}'.format(
package, '\n- '.join(sorted(what_depends_on))))
return False
return result
def packages_to_ignore(self, project):
comments = self.commentapi.get_comments(project_name=project)
ignore_re = re.compile(r'^installcheck: ignore (?P<args>.*)$', re.MULTILINE)
# the last wins, for now we don't care who said it
args = []
for comment in comments.values():
match = ignore_re.search(comment['comment'].replace('\r', ''))
if not match:
continue
args = match.group('args').strip()
# allow space and comma to seperate
args = args.replace(',', ' ').split(' ')
return args
def staging(self, project, force=False):
api = self.api
repository = self.api.cmain_repo
# fetch the build ids at the beginning - mirroring takes a while
buildids = {}
try:
architectures = self.target_archs(project, repository)
except HTTPError as e:
if e.code == 404:
# adi disappear all the time, so don't worry
return False
raise e
all_done = True
for arch in architectures:
pra = '{}/{}/{}'.format(project, repository, arch)
buildid = self.buildid(project, repository, arch)
if not buildid:
self.logger.error('No build ID in {}'.format(pra))
return False
buildids[arch] = buildid
url = self.report_url(project, repository, arch, buildid)
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
check = root.find('check[@name="installcheck"]/state')
if check is not None and check.text != 'pending':
self.logger.info('{} already "{}", ignoring'.format(pra, check.text))
else:
all_done = False
except HTTPError:
self.logger.info('{} has no status report'.format(pra))
all_done = False
if all_done and not force:
return True
repository_pairs = repository_path_expand(api.apiurl, project, repository)
staging_pair = [project, repository]
result = True
status = api.project_status(project)
if not status:
self.logger.error('no project status for {}'.format(project))
return False
result_comment = []
to_ignore = self.packages_to_ignore(project)
meta = api.load_prj_pseudometa(status['description'])
for req in meta['requests']:
if req['type'] == 'delete':
result = result and self.check_delete_request(req, to_ignore, result_comment)
for arch in architectures:
# hit the first repository in the target project (if existant)
target_pair = None
directories = []
for pair_project, pair_repository in repository_pairs:
# ignore repositories only inherited for config
if repository_arch_state(self.api.apiurl, pair_project, pair_repository, arch):
if not target_pair and pair_project == api.project:
target_pair = [pair_project, pair_repository]
directories.append(self.mirror(pair_project, pair_repository, arch))
if not api.is_adi_project(project):
# For "leaky" ring packages in letter stagings, where the
# repository setup does not include the target project, that are
# not intended to to have all run-time dependencies satisfied.
whitelist = self.ring_whitelist
else:
whitelist = self.existing_problems
whitelist |= set(to_ignore)
check = self.cycle_check(project, repository, arch)
if not check.success:
self.logger.warn('Cycle check failed')
result_comment.append(check.comment)
result = False
check = self.install_check(target_pair, arch, directories, None, whitelist)
if not check.success:
self.logger.warn('Install check failed')
result_comment.append(check.comment)
result = False
if result:
self.report_state('success', self.gocd_url(), project, repository, buildids)
else:
result_comment.insert(0, 'Generated from {}\n'.format(self.gocd_url()))
self.report_state('failure', self.upload_failure(project, result_comment), project, repository, buildids)
self.logger.warn('Not accepting {}'.format(project))
return False
return result
def upload_failure(self, project, comment):
print(project, '\n'.join(comment))
url = self.api.makeurl(['source', 'home:repo-checker', 'reports', project])
osc.core.http_PUT(url, data='\n'.join(comment))
url = self.api.apiurl.replace('api.', 'build.')
return '{}/package/view_file/home:repo-checker/reports/{}'.format(url, project)
def report_state(self, state, report_url, project, repository, buildids):
architectures = self.target_archs(project, repository)
for arch in architectures:
self.report_pipeline(state, report_url, project, repository, arch, buildids[arch], arch == architectures[-1])
def gocd_url(self):
if not os.environ.get('GO_SERVER_URL'):
# placeholder :)
return 'http://stephan.kulow.org/'
report_url = os.environ.get('GO_SERVER_URL').replace(':8154', '')
return report_url + '/tab/build/detail/{}/{}/{}/{}/{}#tab-console'.format(os.environ.get('GO_PIPELINE_NAME'),
os.environ.get('GO_PIPELINE_COUNTER'),
os.environ.get('GO_STAGE_NAME'),
os.environ.get('GO_STAGE_COUNTER'),
os.environ.get('GO_JOB_NAME'))
def buildid(self, project, repository, architecture):
url = self.api.makeurl(['build', project, repository, architecture], {'view': 'status'})
root = ET.parse(osc.core.http_GET(url)).getroot()
buildid = root.find('buildid')
if buildid is None:
return False
return buildid.text
def report_url(self, project, repository, architecture, buildid):
return self.api.makeurl(['status_reports', 'built', project,
repository, architecture, 'reports', buildid])
def report_pipeline(self, state, report_url, project, repository, architecture, buildid, is_last):
url = self.report_url(project, repository, architecture, buildid)
name = 'installcheck'
# this is a little bit ugly, but we don't need 2 failures. So save a success for the
# other archs to mark them as visited - pending we put in both
if not is_last:
if state == 'failure':
state = 'success'
xml = self.check_xml(report_url, state, name)
try:
osc.core.http_POST(url, data=xml)
except HTTPError:
print('failed to post status to ' + url)
sys.exit(1)
def check_xml(self, url, state, name):
check = ET.Element('check')
if url:
se = ET.SubElement(check, 'url')
se.text = url
se = ET.SubElement(check, 'state')
se.text = state
se = ET.SubElement(check, 'name')
se.text = name
return ET.tostring(check)
def target_archs(self, project, repository):
archs = target_archs(self.api.apiurl, project, repository)
# Check for arch whitelist and use intersection.
if self.arch_whitelist:
archs = list(self.arch_whitelist.intersection(set(archs)))
# Trick to prioritize x86_64.
return sorted(archs, reverse=True)
@memoize(ttl=60, session=True, add_invalidate=True)
def mirror(self, project, repository, arch):
"""Call bs_mirrorfull script to mirror packages."""
directory = os.path.join(CACHEDIR, project, repository, arch)
if not os.path.exists(directory):
os.makedirs(directory)
script = os.path.join(SCRIPT_PATH, 'bs_mirrorfull')
path = '/'.join((project, repository, arch))
url = '{}/public/build/{}'.format(self.api.apiurl, path)
parts = ['LC_ALL=C', 'perl', script, '--nodebug', url, directory]
parts = [pipes.quote(part) for part in parts]
self.logger.info('mirroring {}'.format(path))
if os.system(' '.join(parts)):
raise Exception('failed to mirror {}'.format(path))
return directory
@memoize(session=True)
def binary_list_existing_problem(self, project, repository):
"""Determine which binaries are mentioned in repo_checker output."""
binaries = set()
filename = self.project_pseudometa_file_name(project, repository)
content = project_pseudometa_file_load(self.api.apiurl, project, filename)
if not content:
self.logger.warn('no project_only run from which to extract existing problems')
return binaries
sections = self.install_check_parse(content)
for section in sections:
for binary in section.binaries:
match = re.match(BINARY_REGEX, binary)
if match:
binaries.add(match.group('name'))
return binaries
def install_check(self, target_project_pair, arch, directories,
ignore=None, whitelist=[], parse=False, no_filter=False):
self.logger.info('install check: start (ignore:{}, whitelist:{}, parse:{}, no_filter:{})'.format(
bool(ignore), len(whitelist), parse, no_filter))
with tempfile.NamedTemporaryFile() as ignore_file:
# Print ignored rpms on separate lines in ignore file.
if ignore:
for item in ignore:
ignore_file.write(item + '\n')
ignore_file.flush()
# Invoke repo_checker.pl to perform an install check.
script = os.path.join(SCRIPT_PATH, 'repo_checker.pl')
parts = ['LC_ALL=C', 'perl', script, arch, ','.join(directories),
'-f', ignore_file.name, '-w', ','.join(whitelist)]
if no_filter:
parts.append('--no-filter')
parts = [pipes.quote(part) for part in parts]
p = subprocess.Popen(' '.join(parts), shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE, close_fds=True)
stdout, stderr = p.communicate()
if p.returncode:
self.logger.info('install check: failed')
if p.returncode == 126:
self.logger.warn('mirror cache reset due to corruption')
self._invalidate_all()
elif parse:
# Parse output for later consumption for posting comments.
sections = self.install_check_parse(stdout)
self.install_check_sections_group(
target_project_pair[0], target_project_pair[1], arch, sections)
# Format output as markdown comment.
parts = []
stdout = stdout.strip()
if stdout:
parts.append(stdout + '\n')
stderr = stderr.strip()
if stderr:
parts.append(stderr + '\n')
header = '### [install check & file conflicts for {}]'.format(arch)
return CheckResult(False, header + '\n\n' + ('\n' + ('-' * 80) + '\n\n').join(parts))
self.logger.info('install check: passed')
return CheckResult(True, None)
def install_check_sections_group(self, project, repository, arch, sections):
_, binary_map = package_binary_list(self.api.apiurl, project, repository, arch)
for section in sections:
# If switch to creating bugs likely makes sense to join packages to
# form grouping key and create shared bugs for conflicts.
# Added check for b in binary_map after encountering:
# https://lists.opensuse.org/opensuse-buildservice/2017-08/msg00035.html
# Under normal circumstances this should never occur.
packages = set([binary_map[b] for b in section.binaries if b in binary_map])
for package in packages:
self.package_results.setdefault(package, [])
self.package_results[package].append(section)
def install_check_parse(self, output):
section = None
text = None
# Loop over lines and parse into chunks assigned to binaries.
for line in output.splitlines(True):
if line.startswith(' '):
if section:
text += line
else:
if section:
yield InstallSection(section, text)
match = re.match(INSTALL_REGEX, line)
if match:
# Remove empty groups since regex matches different patterns.
binaries = [b for b in match.groups() if b is not None]
section = binaries
text = line
else:
section = None
if section:
yield InstallSection(section, text)
def calculate_allowed_cycles(self):
self.allowed_cycles = []
if self.cycle_packages:
for comma_list in self.cycle_packages.split(';'):
self.allowed_cycles.append(comma_list.split(','))
def cycle_check(self, project, repository, arch):
self.logger.info('cycle check: start %s/%s/%s' % (project, repository, arch))
comment = []
depinfo = builddepinfo(self.api.apiurl, project, repository, arch, order = False)
for cycle in depinfo.findall('cycle'):
for package in cycle.findall('package'):
package = package.text
allowed = False
for acycle in self.allowed_cycles:
if package in acycle:
allowed = True
break
if not allowed:
cycled = [p.text for p in cycle.findall('package')]
comment.append('Package {} appears in cycle {}'.format(package, '/'.join(cycled)))
if len(comment):
# New cycles, post comment.
self.logger.info('cycle check: failed')
return CheckResult(False, '\n'.join(comment) + '\n')
self.logger.info('cycle check: passed')
return CheckResult(True, None)
def project_pseudometa_file_name(self, project, repository):
filename = 'repo_checker'
main_repo = Config.get(self.api.apiurl, project).get('main-repo')
if not main_repo:
filename += '.' + repository
return filename
class ABIChecker(ReviewBot.ReviewBot):
""" check ABI of library packages
"""
def __init__(self, *args, **kwargs):
ReviewBot.ReviewBot.__init__(self, *args, **kwargs)
self.no_review = False
self.force = False
self.ts = rpm.TransactionSet()
self.ts.setVSFlags(rpm._RPMVSF_NOSIGNATURES)
# reports of source submission
self.reports = []
# textual report summary for use in accept/decline message
# or comments
self.text_summary = ''
self.session = DB.db_session()
self.dblogger = LogToDB(self.session)
self.logger.addFilter(self.dblogger)
self.commentapi = CommentAPI(self.apiurl)
def check_source_submission(self, src_project, src_package, src_rev, dst_project, dst_package):
# happens for maintenance incidents
if dst_project == None and src_package == 'patchinfo':
return None
if dst_project in PROJECT_BLACKLIST:
self.logger.info(PROJECT_BLACKLIST[dst_project])
# self.text_summary += PROJECT_BLACKLIST[dst_project] + "\n"
return True
# default is to accept the review, just leave a note if
# there were problems.
ret = True
ReviewBot.ReviewBot.check_source_submission(self, src_project, src_package, src_rev, dst_project, dst_package)
report = Report(src_project, src_package, src_rev, dst_project, dst_package, [], None)
dst_srcinfo = self.get_sourceinfo(dst_project, dst_package)
self.logger.debug('dest sourceinfo %s', pformat(dst_srcinfo))
if dst_srcinfo is None:
msg = "%s/%s seems to be a new package, no need to review"%(dst_project, dst_package)
self.logger.info(msg)
self.text_summary += msg + "\n"
self.reports.append(report)
return True
src_srcinfo = self.get_sourceinfo(src_project, src_package, src_rev)
self.logger.debug('src sourceinfo %s', pformat(src_srcinfo))
if src_srcinfo is None:
msg = "%s/%s@%s does not exist!? can't check"%(src_project, src_package, src_rev)
self.logger.error(msg)
self.text_summary += msg + "\n"
self.reports.append(report)
return False
if os.path.exists(UNPACKDIR):
shutil.rmtree(UNPACKDIR)
try:
# compute list of common repos to find out what to compare
myrepos = self.findrepos(src_project, src_srcinfo, dst_project, dst_srcinfo)
except NoBuildSuccess as e:
self.logger.info(e)
self.text_summary += "**Error**: %s\n"%e
self.reports.append(report)
return False
except NotReadyYet as e:
self.logger.info(e)
self.reports.append(report)
return None
except SourceBroken as e:
self.logger.error(e)
self.text_summary += "**Error**: %s\n"%e
self.reports.append(report)
return False
if not myrepos:
self.text_summary += "**Error**: %s does not build against %s, can't check library ABIs\n\n"%(src_project, dst_project)
self.logger.info("no matching repos, can't compare")
self.reports.append(report)
return False
# *** beware of nasty maintenance stuff ***
# if the destination is a maintained project we need to
# mangle our comparison target and the repo mapping
try:
originproject, originpackage, origin_srcinfo, new_repo_map = self._maintenance_hack(dst_project, dst_srcinfo, myrepos)
if originproject is not None:
dst_project = originproject
if originpackage is not None:
dst_package = originpackage
if origin_srcinfo is not None:
dst_srcinfo = origin_srcinfo
if new_repo_map is not None:
myrepos = new_repo_map
except MaintenanceError as e:
self.text_summary += "**Error**: %s\n\n"%e
self.logger.error('%s', e)
self.reports.append(report)
return False
except NoBuildSuccess as e:
self.logger.info(e)
self.text_summary += "**Error**: %s\n"%e
self.reports.append(report)
return False
except NotReadyYet as e:
self.logger.info(e)
self.reports.append(report)
return None
except SourceBroken as e:
self.logger.error(e)
self.text_summary += "**Error**: %s\n"%e
self.reports.append(report)
return False
notes = []
libresults = []
overall = None
missing_debuginfo = []
for mr in myrepos:
try:
dst_libs = self.extract(dst_project, dst_package, dst_srcinfo, mr.dstrepo, mr.arch)
# nothing to fetch, so no libs
if dst_libs is None:
continue
except DistUrlMismatch as e:
self.logger.error("%s/%s %s/%s: %s"%(dst_project, dst_package, mr.dstrepo, mr.arch, e))
if ret == True: # need to check again
ret = None
continue
except MissingDebugInfo as e:
missing_debuginfo.append(str(e))
ret = False
continue
except FetchError as e:
self.logger.error(e)
if ret == True: # need to check again
ret = None
continue
try:
src_libs = self.extract(src_project, src_package, src_srcinfo, mr.srcrepo, mr.arch)
if src_libs is None:
if dst_libs:
self.text_summary += "*Warning*: the submission does not contain any libs anymore\n\n"
continue
except DistUrlMismatch as e:
self.logger.error("%s/%s %s/%s: %s"%(src_project, src_package, mr.srcrepo, mr.arch, e))
if ret == True: # need to check again
ret = None
continue
except MissingDebugInfo as e:
missing_debuginfo.append(str(e))
ret = False
continue
except FetchError as e:
self.logger.error(e)
if ret == True: # need to check again
ret = None
continue
# create reverse index for aliases in the source project
src_aliases = dict()
for lib in src_libs.keys():
for a in src_libs[lib]:
src_aliases.setdefault(a, set()).add(lib)
# for each library in the destination project check if the same lib
# exists in the source project. If not check the aliases (symlinks)
# to catch soname changes. Generate pairs of matching libraries.
pairs = set()
for lib in dst_libs.keys():
if lib in src_libs:
pairs.add((lib, lib))
else:
self.logger.debug("%s not found in submission, checking aliases", lib)
found = False
for a in dst_libs[lib]:
if a in src_aliases:
for l in src_aliases[a]:
pairs.add((lib, l))
found = True
if found == False:
self.text_summary += "*Warning*: %s no longer packaged\n\n"%lib
self.logger.debug("to diff: %s", pformat(pairs))
# for each pair dump and compare the abi
for old, new in pairs:
# abi dump of old lib
new_base = os.path.join(UNPACKDIR, dst_project, dst_package, mr.dstrepo, mr.arch)
old_dump = os.path.join(CACHEDIR, 'old.dump')
# abi dump of new lib
old_base = os.path.join(UNPACKDIR, src_project, src_package, mr.srcrepo, mr.arch)
new_dump = os.path.join(CACHEDIR, 'new.dump')
def cleanup():
if os.path.exists(old_dump):
os.unlink(old_dump)
if os.path.exists(new_dump):
os.unlink(new_dump)
cleanup()
# we just need that to pass a name to abi checker
m = so_re.match(old)
htmlreport = 'report-%s-%s-%s-%s-%s-%08x.html'%(mr.srcrepo, os.path.basename(old), mr.dstrepo, os.path.basename(new), mr.arch, time.time())
# run abichecker
if m \
and self.run_abi_dumper(old_dump, new_base, old) \
and self.run_abi_dumper(new_dump, old_base, new):
reportfn = os.path.join(CACHEDIR, htmlreport)
r = self.run_abi_checker(m.group(1), old_dump, new_dump, reportfn)
if r is not None:
self.logger.debug('report saved to %s, compatible: %d', reportfn, r)
libresults.append(LibResult(mr.srcrepo, os.path.basename(old), mr.dstrepo, os.path.basename(new), mr.arch, htmlreport, r))
if overall is None:
overall = r
elif overall == True and r == False:
overall = r
else:
self.logger.error('failed to compare %s <> %s'%(old,new))
self.text_summary += "**Error**: ABI check failed on %s vs %s\n\n"%(old, new)
if ret == True: # need to check again
ret = None
cleanup()
if missing_debuginfo:
self.text_summary += 'debug information is missing for the following packages, can\'t check:\n<pre>'
self.text_summary += ''.join(missing_debuginfo)
self.text_summary += '</pre>\nplease enable debug info in your project config.\n'
self.reports.append(report._replace(result = overall, reports = libresults))
# upload reports
if os.path.exists(UNPACKDIR):
shutil.rmtree(UNPACKDIR)
return ret
def _maintenance_hack(self, dst_project, dst_srcinfo, myrepos):
pkg = dst_srcinfo.package
originproject = None
originpackage = None
# find the maintenance project
url = osc.core.makeurl(self.apiurl, ('search', 'project', 'id'),
"match=(maintenance/maintains/@project='%s'+and+attribute/@name='%s')"%(dst_project, osc.conf.config['maintenance_attribute']))
root = ET.parse(osc.core.http_GET(url)).getroot()
if root is not None:
node = root.find('project')
if node is not None:
# check if target project is a project link where the
# sources don't actually build (like openSUSE:...:Update). That
# is the case if no update was released yet.
# XXX: TODO: do check for whether the package builds here first
originproject = self.get_originproject(dst_project, pkg)
if originproject is not None:
self.logger.debug("origin project %s", originproject)
url = osc.core.makeurl(self.apiurl, ('build', dst_project, '_result'), { 'package': pkg })
root = ET.parse(osc.core.http_GET(url)).getroot()
alldisabled = True
for node in root.findall('status'):
if node.get('code') != 'disabled':
alldisabled = False
if alldisabled:
self.logger.debug("all repos disabled, using originproject %s"%originproject)
else:
originproject = None
else:
mproject = node.attrib['name']
# packages are only a link to packagename.incidentnr
(linkprj, linkpkg) = self._get_linktarget(dst_project, pkg)
if linkpkg is not None and linkprj == dst_project:
self.logger.debug("%s/%s links to %s"%(dst_project, pkg, linkpkg))
regex = re.compile(r'.*\.(\d+)$')
m = regex.match(linkpkg)
if m is None:
raise MaintenanceError("%s/%s -> %s/%s is not a proper maintenance link (must match /%s/)"%(dst_project, pkg, linkprj, linkpkg, regex.pattern))
incident = m.group(1)
self.logger.debug("is maintenance incident %s"%incident)
originproject = "%s:%s"%(mproject, incident)
originpackage = pkg+'.'+dst_project.replace(':', '_')
origin_srcinfo = self.get_sourceinfo(originproject, originpackage)
if origin_srcinfo is None:
raise MaintenanceError("%s/%s invalid"%(originproject, originpackage))
# find the map of maintenance incident repos to destination repos
originrepos = self.findrepos(originproject, origin_srcinfo, dst_project, dst_srcinfo)
mapped = dict()
for mr in originrepos:
mapped[(mr.dstrepo, mr.arch)] = mr
self.logger.debug("mapping: %s", pformat(mapped))
# map the repos of the original request to the maintenance incident repos
matchrepos = set()
for mr in myrepos:
if not (mr.dstrepo, mr.arch) in mapped:
# sometimes a previously released maintenance
# update didn't cover all architectures. We can
# only ignore that then.
self.logger.warn("couldn't find repo %s/%s in %s/%s"%(mr.dstrepo, mr.arch, originproject, originpackage))
continue
matchrepos.add(MR(mr.srcrepo, mapped[(mr.dstrepo, mr.arch)].srcrepo, mr.arch))
myrepos = matchrepos
dst_srcinfo = origin_srcinfo
self.logger.debug("new repo map: %s", pformat(myrepos))
return (originproject, originpackage, dst_srcinfo, myrepos)
def find_abichecker_comment(self, req):
"""Return previous comments (should be one)."""
comments = self.commentapi.get_comments(request_id=req.reqid)
for c in comments.values():
m = comment_marker_re.match(c['comment'])
if m:
return c['id'], m.group('state'), m.group('result')
return None, None, None
def check_one_request(self, req):
self.review_messages = ReviewBot.ReviewBot.DEFAULT_REVIEW_MESSAGES
if self.no_review and not self.force and self.check_request_already_done(req.reqid):
self.logger.info("skip request %s which is already done", req.reqid)
# TODO: check if the request was seen before and we
# didn't reach a final state for too long
return None
commentid, state, result = self.find_abichecker_comment(req)
## using comments instead of db would be an options for bots
## that use no db
# if self.no_review:
# if state == 'done':
# self.logger.debug("request %s already done, result: %s"%(req.reqid, result))
# return
self.dblogger.request_id = req.reqid
self.reports = []
self.text_summary = ''
try:
ret = ReviewBot.ReviewBot.check_one_request(self, req)
except Exception as e:
import traceback
self.logger.error("unhandled exception in ABI checker")
self.logger.error(traceback.format_exc())
ret = None
result = None
if ret is not None:
state = 'done'
result = 'accepted' if ret else 'declined'
else:
# we probably don't want abichecker to spam here
# FIXME don't delete comment in this case
#if state is None and not self.text_summary:
# self.text_summary = 'abichecker will take a look later'
state = 'seen'
self.save_reports_to_db(req, state, result)
if ret is not None and self.text_summary == '':
# if for some reason save_reports_to_db didn't produce a
# summary we add one
self.text_summary = "ABI checker result: [%s](%s/request/%s)"%(result, WEB_URL, req.reqid)
if commentid and not self.dryrun:
self.commentapi.delete(commentid)
self.post_comment(req, state, result)
self.review_messages = { 'accepted': self.text_summary, 'declined': self.text_summary }
if self.no_review:
ret = None
self.dblogger.request_id = None
return ret
def check_request_already_done(self, reqid):
try:
request = self.session.query(DB.Request).filter(DB.Request.id == reqid).one()
if request.state == 'done':
return True
except sqlalchemy.orm.exc.NoResultFound as e:
pass
return False
def save_reports_to_db(self, req, state, result):
try:
request = self.session.query(DB.Request).filter(DB.Request.id == req.reqid).one()
for i in self.session.query(DB.ABICheck).filter(DB.ABICheck.request_id == request.id).all():
# yeah, we could be smarter here and update existing reports instead
self.session.delete(i)
self.session.flush()
request.state = state
request.result = result
except sqlalchemy.orm.exc.NoResultFound as e:
request = DB.Request(id = req.reqid,
state = state,
result = result,
)
self.session.add(request)
self.session.commit()
for r in self.reports:
abicheck = DB.ABICheck(
request = request,
src_project = r.src_project,
src_package = r.src_package,
src_rev = r.src_rev,
dst_project = r.dst_project,
dst_package = r.dst_package,
result = r.result
)
self.session.add(abicheck)
self.session.commit()
if r.result is None:
continue
elif r.result:
self.text_summary += "Good news from ABI check, "
self.text_summary += "%s seems to be ABI [compatible](%s/request/%s):\n\n"%(r.dst_package, WEB_URL, req.reqid)
else:
self.text_summary += "Warning: bad news from ABI check, "
self.text_summary += "%s may be ABI [**INCOMPATIBLE**](%s/request/%s):\n\n"%(r.dst_package, WEB_URL, req.reqid)
for lr in r.reports:
libreport = DB.LibReport(
abicheck = abicheck,
src_repo = lr.src_repo,
src_lib = lr.src_lib,
dst_repo = lr.dst_repo,
dst_lib = lr.dst_lib,
arch = lr.arch,
htmlreport = lr.htmlreport,
result = lr.result,
)
self.session.add(libreport)
self.session.commit()
self.text_summary += "* %s (%s): [%s](%s/report/%d)\n"%(lr.dst_lib, lr.arch,
"compatible" if lr.result else "***INCOMPATIBLE***",
WEB_URL, libreport.id)
self.reports = []
def post_comment(self, req, state, result):
if not self.text_summary:
return
msg = "<!-- abichecker state=%s%s -->\n"%(state, ' result=%s'%result if result else '')
msg += self.text_summary
self.logger.info("add comment: %s"%msg)
if not self.dryrun:
#self.commentapi.delete_from_where_user(self.review_user, request_id = req.reqid)
self.commentapi.add_comment(request_id = req.reqid, comment = msg)
def run_abi_checker(self, libname, old, new, output):
cmd = ['abi-compliance-checker',
'-lib', libname,
'-old', old,
'-new', new,
'-report-path', output
]
self.logger.debug(cmd)
r = subprocess.Popen(cmd, close_fds=True, cwd=CACHEDIR).wait()
if not r in (0, 1):
self.logger.error('abi-compliance-checker failed')
# XXX: record error
return None
return r == 0
def run_abi_dumper(self, output, base, filename):
cmd = ['abi-dumper',
'-o', output,
'-lver', os.path.basename(filename),
'/'.join([base, filename])]
debuglib = '%s/usr/lib/debug/%s.debug'%(base, filename)
if os.path.exists(debuglib):
cmd.append(debuglib)
self.logger.debug(cmd)
r = subprocess.Popen(cmd, close_fds=True, cwd=CACHEDIR).wait()
if r != 0:
self.logger.error("failed to dump %s!"%filename)
# XXX: record error
return False
return True
def extract(self, project, package, srcinfo, repo, arch):
# fetch cpio headers
# check file lists for library packages
fetchlist, liblist = self.compute_fetchlist(project, package, srcinfo, repo, arch)
if not fetchlist:
msg = "no libraries found in %s/%s %s/%s"%(project, package, repo, arch)
self.logger.info(msg)
return None
# mtimes in cpio are not the original ones, so we need to fetch
# that separately :-(
mtimes= self._getmtimes(project, package, repo, arch)
self.logger.debug("fetchlist %s", pformat(fetchlist))
self.logger.debug("liblist %s", pformat(liblist))
debugfiles = set(['/usr/lib/debug%s.debug'%f for f in liblist])
# fetch binary rpms
downloaded = self.download_files(project, package, repo, arch, fetchlist, mtimes)
# extract binary rpms
tmpfile = os.path.join(CACHEDIR, "cpio")
for fn in fetchlist:
self.logger.debug("extract %s"%fn)
with open(tmpfile, 'wb') as tmpfd:
if not fn in downloaded:
raise FetchError("%s was not downloaded!"%fn)
self.logger.debug(downloaded[fn])
r = subprocess.call(['rpm2cpio', downloaded[fn]], stdout=tmpfd, close_fds=True)
if r != 0:
raise FetchError("failed to extract %s!"%fn)
tmpfd.close()
os.unlink(downloaded[fn])
cpio = CpioRead(tmpfile)
cpio.read()
for ch in cpio:
fn = ch.filename
if fn.startswith('./'): # rpm payload is relative
fn = fn[1:]
self.logger.debug("cpio fn %s", fn)
if not fn in liblist and not fn in debugfiles:
continue
dst = os.path.join(UNPACKDIR, project, package, repo, arch)
dst += fn
if not os.path.exists(os.path.dirname(dst)):
os.makedirs(os.path.dirname(dst))
self.logger.debug("dst %s", dst)
# the filehandle in the cpio archive is private so
# open it again
with open(tmpfile, 'rb') as cpiofh:
cpiofh.seek(ch.dataoff, os.SEEK_SET)
with open(dst, 'wb') as fh:
while True:
buf = cpiofh.read(4096)
if buf is None or buf == '':
break
fh.write(buf)
os.unlink(tmpfile)
return liblist
def download_files(self, project, package, repo, arch, filenames, mtimes):
downloaded = dict()
for fn in filenames:
if not fn in mtimes:
raise FetchError("missing mtime information for %s, can't check"% fn)
repodir = os.path.join(DOWNLOADS, package, project, repo)
if not os.path.exists(repodir):
os.makedirs(repodir)
t = os.path.join(repodir, fn)
self._get_binary_file(project, repo, arch, package, fn, t, mtimes[fn])
downloaded[fn] = t
return downloaded
def _get_binary_file(self, project, repository, arch, package, filename, target, mtime):
"""Get a binary file from OBS."""
# Used to cache, but dropped as part of python3 migration.
osc.core.get_binary_file(self.apiurl, project, repository, arch,
filename, package=package,
target_filename=target)
def readRpmHeaderFD(self, fd):
h = None
try:
h = self.ts.hdrFromFdno(fd)
except rpm.error as e:
if str(e) == "public key not available":
print str(e)
if str(e) == "public key not trusted":
print str(e)
if str(e) == "error reading package header":
print str(e)
h = None
return h
def _fetchcpioheaders(self, project, package, repo, arch):
u = osc.core.makeurl(self.apiurl, [ 'build', project, repo, arch, package ],
[ 'view=cpioheaders' ])
try:
r = osc.core.http_GET(u)
except HTTPError as e:
raise FetchError('failed to fetch header information: %s'%e)
tmpfile = NamedTemporaryFile(prefix="cpio-", delete=False)
for chunk in r:
tmpfile.write(chunk)
tmpfile.close()
cpio = CpioRead(tmpfile.name)
cpio.read()
rpm_re = re.compile('(.+\.rpm)-[0-9A-Fa-f]{32}$')
for ch in cpio:
# ignore errors
if ch.filename == '.errors':
continue
# the filehandle in the cpio archive is private so
# open it again
with open(tmpfile.name, 'rb') as fh:
fh.seek(ch.dataoff, os.SEEK_SET)
h = self.readRpmHeaderFD(fh)
if h is None:
raise FetchError("failed to read rpm header for %s"%ch.filename)
m = rpm_re.match(ch.filename)
if m:
yield m.group(1), h
os.unlink(tmpfile.name)
def _getmtimes(self, prj, pkg, repo, arch):
""" returns a dict of filename: mtime """
url = osc.core.makeurl(self.apiurl, ('build', prj, repo, arch, pkg))
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
except HTTPError:
return None
return dict([(node.attrib['filename'], node.attrib['mtime']) for node in root.findall('binary')])
# modified from repochecker
def _last_build_success(self, src_project, tgt_project, src_package, rev):
"""Return the last build success XML document from OBS."""
try:
query = { 'lastsuccess' : 1,
'package' : src_package,
'pathproject' : tgt_project,
'srcmd5' : rev }
url = osc.core.makeurl(self.apiurl, ('build', src_project, '_result'), query)
return ET.parse(osc.core.http_GET(url)).getroot()
except HTTPError as e:
if e.code != 404:
self.logger.error('ERROR in URL %s [%s]' % (url, e))
raise
pass
return None
def get_buildsuccess_repos(self, src_project, tgt_project, src_package, rev):
root = self._last_build_success(src_project, tgt_project, src_package, rev)
if root is None:
return None
# build list of repos as set of (name, arch) tuples
repos = set()
for repo in root.findall('repository'):
name = repo.attrib['name']
for node in repo.findall('arch'):
repos.add((name, node.attrib['arch']))
self.logger.debug("success repos: %s", pformat(repos))
return repos
def get_dstrepos(self, project):
url = osc.core.makeurl(self.apiurl, ('source', project, '_meta'))
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
except HTTPError:
return None
repos = set()
for repo in root.findall('repository'):
name = repo.attrib['name']
if project in REPO_WHITELIST and name not in REPO_WHITELIST[project]:
continue
for node in repo.findall('arch'):
arch = node.text
if project in ARCH_WHITELIST and arch not in ARCH_WHITELIST[project]:
continue
repos.add((name, arch))
return repos
def ensure_settled(self, src_project, src_srcinfo, matchrepos):
""" make sure current build state is final so we're not
tricked with half finished results"""
rmap = dict()
results = osc.core.get_package_results(self.apiurl,
src_project, src_srcinfo.package,
repository = [ mr.srcrepo for mr in matchrepos],
arch = [ mr.arch for mr in matchrepos])
for result in results:
for res, _ in osc.core.result_xml_to_dicts(result):
if not 'package' in res or res['package'] != src_srcinfo.package:
continue
rmap[(res['repository'], res['arch'])] = res
for mr in matchrepos:
if not (mr.srcrepo, mr.arch) in rmap:
self.logger.warn("%s/%s had no build success"%(mr.srcrepo, mr.arch))
raise NotReadyYet(src_project, src_srcinfo.package, "no result")
if rmap[(mr.srcrepo, mr.arch)]['dirty']:
self.logger.warn("%s/%s dirty"%(mr.srcrepo, mr.arch))
raise NotReadyYet(src_project, src_srcinfo.package, "dirty")
code = rmap[(mr.srcrepo, mr.arch)]['code']
if code == 'broken':
raise SourceBroken(src_project, src_srcinfo.package)
if code != 'succeeded' and code != 'locked' and code != 'excluded':
self.logger.warn("%s/%s not succeeded (%s)"%(mr.srcrepo, mr.arch, code))
raise NotReadyYet(src_project, src_srcinfo.package, code)
def findrepos(self, src_project, src_srcinfo, dst_project, dst_srcinfo):
# get target repos that had a successful build
dstrepos = self.get_dstrepos(dst_project)
if dstrepos is None:
return None
url = osc.core.makeurl(self.apiurl, ('source', src_project, '_meta'))
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
except HTTPError:
return None
# set of source repo name, target repo name, arch
matchrepos = set()
for repo in root.findall('repository'):
name = repo.attrib['name']
path = repo.findall('path')
if path is None or len(path) != 1:
self.logger.error("repo %s has more than one path"%name)
continue
prj = path[0].attrib['project']
if prj == 'openSUSE:Tumbleweed':
prj = 'openSUSE:Factory' # XXX: hack
if prj != dst_project:
continue
for node in repo.findall('arch'):
arch = node.text
dstname = path[0].attrib['repository']
if (dstname, arch) in dstrepos:
matchrepos.add(MR(name, dstname, arch))
if not matchrepos:
return None
else:
self.logger.debug('matched repos %s', pformat(matchrepos))
# make sure it's not dirty
self.ensure_settled(src_project, src_srcinfo, matchrepos)
# now check if all matched repos built successfully
srcrepos = self.get_buildsuccess_repos(src_project, dst_project, src_srcinfo.package, src_srcinfo.verifymd5)
if srcrepos is None:
raise NotReadyYet(src_project, src_srcinfo.package, "no build success")
if not srcrepos:
raise NoBuildSuccess(src_project, src_srcinfo.package, src_srcinfo.verifymd5)
for mr in matchrepos:
if not (mr.srcrepo, arch) in srcrepos:
self.logger.error("%s/%s had no build success"%(mr.srcrepo, arch))
raise NoBuildSuccess(src_project, src_srcinfo.package, src_srcinfo.verifymd5)
return matchrepos
# common with repochecker
def _md5_disturl(self, disturl):
"""Get the md5 from the DISTURL from a RPM file."""
return os.path.basename(disturl).split('-')[0]
def disturl_matches_md5(self, disturl, md5):
if self._md5_disturl(disturl) != md5:
return False
return True
# this is a bit magic. OBS allows to take the disturl md5 from the package
# and query the source info for that. We will then get the verify md5 that
# belongs to that md5.
def disturl_matches(self, disturl, prj, srcinfo):
md5 = self._md5_disturl(disturl)
info = self.get_sourceinfo(prj, srcinfo.package, rev = md5)
self.logger.debug(pformat(srcinfo))
self.logger.debug(pformat(info))
if info.verifymd5 == srcinfo.verifymd5:
return True
return False
def compute_fetchlist(self, prj, pkg, srcinfo, repo, arch):
""" scan binary rpms of the specified repo for libraries.
Returns a set of packages to fetch and the libraries found
"""
self.logger.debug('scanning %s/%s %s/%s'%(prj, pkg, repo, arch))
headers = self._fetchcpioheaders(prj, pkg, repo, arch)
missing_debuginfo = set()
lib_packages = dict() # pkgname -> set(lib file names)
pkgs = dict() # pkgname -> cpiohdr, rpmhdr
lib_aliases = dict()
for rpmfn, h in headers:
# skip src rpm
if h['sourcepackage']:
continue
pkgname = h['name']
if pkgname.endswith('-32bit') or pkgname.endswith('-64bit'):
# -32bit and -64bit packages are just repackaged, so
# we skip them and only check the original one.
continue
self.logger.debug(pkgname)
if not self.disturl_matches(h['disturl'], prj, srcinfo):
raise DistUrlMismatch(h['disturl'], srcinfo)
pkgs[pkgname] = (rpmfn, h)
if debugpkg_re.match(pkgname):
continue
for fn, mode, lnk in zip(h['filenames'], h['filemodes'], h['filelinktos']):
if so_re.match(fn):
if S_ISREG(mode):
self.logger.debug('found lib: %s'%fn)
lib_packages.setdefault(pkgname, set()).add(fn)
elif S_ISLNK(mode) and lnk is not None:
alias = os.path.basename(fn)
libname = os.path.basename(lnk)
self.logger.debug('found alias: %s -> %s'%(alias, libname))
lib_aliases.setdefault(libname, set()).add(alias)
fetchlist = set()
liblist = dict()
# check whether debug info exists for each lib
for pkgname in sorted(lib_packages.keys()):
dpkgname = pkgname+'-debuginfo'
if not dpkgname in pkgs:
missing_debuginfo.add((prj, pkg, repo, arch, pkgname))
continue
# check file list of debuginfo package
rpmfn, h = pkgs[dpkgname]
files = set (h['filenames'])
ok = True
for lib in lib_packages[pkgname]:
fn = '/usr/lib/debug%s.debug'%lib
if not fn in files:
missing_debuginfo.add((prj, pkg, repo, arch, pkgname, lib))
ok = False
if ok:
fetchlist.add(pkgs[pkgname][0])
fetchlist.add(rpmfn)
liblist.setdefault(lib, set())
libname = os.path.basename(lib)
if libname in lib_aliases:
liblist[lib] |= lib_aliases[libname]
if missing_debuginfo:
self.logger.error('missing debuginfo: %s'%pformat(missing_debuginfo))
raise MissingDebugInfo(missing_debuginfo)
return fetchlist, liblist
class OpenQABot(ReviewBot.ReviewBot):
""" check ABI of library packages
"""
def __init__(self, *args, **kwargs):
super(OpenQABot, self).__init__(*args, **kwargs)
self.tgt_repo = {}
self.project_settings = {}
self.api_map = {}
self.bot_name = 'openqa'
self.force = False
self.openqa = None
self.commentapi = CommentAPI(self.apiurl)
def gather_test_builds(self):
for prj, u in self.tgt_repo[self.openqa.baseurl].items():
buildnr = 0
cjob = 0
for j in self.jobs_for_target(u):
# avoid going backwards in job ID
if cjob > int(j['id']):
continue
buildnr = j['settings']['BUILD']
cjob = int(j['id'])
self.update_test_builds[prj] = buildnr
jobs = self.jobs_for_target(u, build=buildnr)
self.openqa_jobs[prj] = jobs
if self.calculate_qa_status(jobs) == QA_INPROGRESS:
self.pending_target_repos.add(prj)
# reimplemention from baseclass
def check_requests(self):
# to be filled by repos of active
self.incident_repos = dict()
self.update_test_builds = {}
self.pending_target_repos = set()
self.openqa_jobs = {}
if self.ibs:
self.check_suse_incidents()
else:
self.check_opensuse_incidents()
# first calculate the latest build number for current jobs
self.gather_test_builds()
super(OpenQABot, self).check_requests()
# now make sure the jobs are for current repo
for prj, u in self.tgt_repo[self.openqa.baseurl].items():
if prj in self.pending_target_repos:
self.logger.debug("Do not trigger for " + prj)
continue
self.trigger_build_for_target(prj, u)
# check a set of repos for their primary checksums
@staticmethod
def calculate_repo_hash(repos, incidents):
m = md5.new()
# if you want to force it, increase this number
m.update('b')
for url in repos:
url += '/repodata/repomd.xml'
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
except HTTPError:
raise
cs = root.find(
'.//{http://linux.duke.edu/metadata/repo}data[@type="primary"]/{http://linux.duke.edu/metadata/repo}checksum')
m.update(cs.text)
# now add the open incidents
m.update(json.dumps(incidents, sort_keys=True))
digest = m.hexdigest()
open_incidents = sorted(incidents.keys())
if open_incidents:
digest += ':' + ','.join(open_incidents)
return digest
def is_incident_in_testing(self, incident):
# hard coded for now as we only run this code for SUSE Maintenance workflow
project = 'SUSE:Maintenance:{}'.format(incident)
xpath = "(state/@name='review') and (action/source/@project='{}' and action/@type='maintenance_release')".format(project)
res = osc.core.search(self.apiurl, request=xpath)['request']
# return the one and only (or None)
return res.find('request')
def calculate_incidents(self, incidents):
"""
get incident numbers from SUSE:Maintenance:Test project
returns dict with openQA var name : string with numbers
"""
self.logger.debug("calculate_incidents: {}".format(pformat(incidents)))
l_incidents = []
for kind, prj in incidents.items():
packages = osc.core.meta_get_packagelist(self.apiurl, prj)
incidents = []
# filter out incidents in staging
for incident in packages:
# remove patchinfo. prefix
incident = incident.replace('_', '.').split('.')[1]
req = self.is_incident_in_testing(incident)
# without release request it's in staging
if not req:
continue
# skip kgraft patches from aggregation
req_ = osc.core.Request()
req_.read(req)
src_prjs = {a.src_project for a in req_.actions}
if SUSEUpdate.kgraft_target(self.apiurl, src_prjs.pop()):
self.logger.debug(
"calculate_incidents: Incident is kgraft - {} ".format(incident))
continue
incidents.append(incident)
l_incidents.append((kind + '_TEST_ISSUES', ','.join(incidents)))
self.logger.debug("Calculate incidents:{}".format(pformat(l_incidents)))
return l_incidents
def jobs_for_target(self, data, build=None):
settings = data['settings']
values = {
'distri': settings['DISTRI'],
'version': settings['VERSION'],
'arch': settings['ARCH'],
'flavor': settings['FLAVOR'],
'scope': 'relevant',
'latest': '1',
}
if build:
values['build'] = build
else:
values['test'] = data['test']
self.logger.debug("Get jobs: {}".format(pformat(values)))
return self.openqa.openqa_request('GET', 'jobs', values)['jobs']
# we don't know the current BUILD and querying all jobs is too expensive
# so we need to check for one known TEST first
# if that job doesn't contain the proper hash, we trigger a new one
# and then we know the build
def trigger_build_for_target(self, prj, data):
today = date.today().strftime("%Y%m%d")
try:
repohash = self.calculate_repo_hash(data['repos'], self.incident_repos.get(prj, {}))
except HTTPError as e:
self.logger.debug("REPOHASH not calculated with response {}".format(e))
return
buildnr = None
jobs = self.jobs_for_target(data)
for job in jobs:
if job['settings'].get('REPOHASH', '') == repohash:
# take the last in the row
buildnr = job['settings']['BUILD']
self.update_test_builds[prj] = buildnr
# ignore old build numbers, we want a fresh run every day
# to find regressions in the tests and to get data about
# randomly failing tests
if buildnr and buildnr.startswith(today):
return
buildnr = 0
# not found, then check for the next free build nr
for job in jobs:
build = job['settings']['BUILD']
if build and build.startswith(today):
try:
nr = int(build.split('-')[1])
if nr > buildnr:
buildnr = nr
except ValueError:
continue
buildnr = "{!s}-{:d}".format(today, buildnr + 1)
s = data['settings']
# now schedule it for real
if 'incidents' in data.keys():
for x, y in self.calculate_incidents(data['incidents']):
s[x] = y
s['BUILD'] = buildnr
s['REPOHASH'] = repohash
self.logger.debug("Prepared: {}".format(pformat(s)))
if not self.dryrun:
try:
self.logger.info("Openqa isos POST {}".format(pformat(s)))
self.openqa.openqa_request('POST', 'isos', data=s, retries=1)
except Exception as e:
self.logger.error(e)
self.update_test_builds[prj] = buildnr
def request_get_openqa_status(self, req):
types = {a.type for a in req.actions}
if 'maintenance_release' not in types:
return [], QA_UNKNOWN
src_prjs = {a.src_project for a in req.actions}
if len(src_prjs) != 1:
raise Exception("can't handle maintenance_release from different incidents")
build = src_prjs.pop()
incident_id = build.split(':')[-1]
tgt_prjs = {a.tgt_project for a in req.actions}
jobs = self.openqa_jobs.get(build, [])
qa_status = self.calculate_qa_status(jobs)
if qa_status == QA_UNKNOWN or qa_status == QA_INPROGRESS:
return jobs, qa_status
# check if the repo jobs include the incident
repo_jobs = []
for prj in sorted(tgt_prjs):
repo_settings = self.tgt_repo.get(self.openqa.baseurl, {})
if prj in repo_settings:
repo_jobs += self.openqa_jobs[prj]
for job in repo_jobs:
foundissue = False
for key, value in job['settings'].items():
if key.endswith('_TEST_ISSUES'):
if incident_id in value.split(','):
foundissue = True
if not foundissue:
self.logger.info("Repo job {} not for {} - ignoring".format(job['id'], incident_id))
return jobs, QA_INPROGRESS
# print(foundissue, incident_id, json.dumps(job['settings'], indent=4))
jobs += repo_jobs
return jobs, self.calculate_qa_status(jobs)
def calculate_qa_status(self, jobs=None):
if not jobs:
return QA_UNKNOWN
j = {}
has_failed = False
in_progress = False
for job in jobs:
if job['clone_id']:
continue
name = job['name']
if name in j and int(job['id']) < int(j[name]['id']):
continue
j[name] = job
if job['state'] not in ('cancelled', 'done'):
in_progress = True
else:
if job['result'] != 'passed' and job['result'] != 'softfailed':
has_failed = True
if not j:
return QA_UNKNOWN
if in_progress:
return QA_INPROGRESS
if has_failed:
return QA_FAILED
return QA_PASSED
# escape markdown
@staticmethod
def emd(str):
return str.replace('_', r'\_')
@staticmethod
def get_step_url(testurl, modulename):
failurl = testurl + '/modules/{!s}/fails'.format(quote_plus(modulename))
fails = requests.get(failurl).json()
failed_step = fails.get('first_failed_step', 1)
return "[{!s}]({!s}#step/{!s}/{:d})".format(OpenQABot.emd(modulename), testurl, modulename, failed_step)
@staticmethod
def job_test_name(job):
return "{!s}@{!s}".format(OpenQABot.emd(job['settings']['TEST']), OpenQABot.emd(job['settings']['MACHINE']))
def summarize_one_openqa_job(self, job):
testurl = osc.core.makeurl(self.openqa.baseurl, ['tests', str(job['id'])])
if not job['result'] in ['passed', 'failed', 'softfailed']:
rstring = job['result']
if rstring == 'none':
return None
return '\n- [{!s}]({!s}) is {!s}'.format(self.job_test_name(job), testurl, rstring)
modstrings = []
for module in job['modules']:
if module['result'] != 'failed':
continue
modstrings.append(self.get_step_url(testurl, module['name']))
if modstrings:
return '\n- [{!s}]({!s}) failed in {!s}'.format(self.job_test_name(job), testurl, ','.join(modstrings))
elif job['result'] == 'failed': # rare case: fail without module fails
return '\n- [{!s}]({!s}) failed'.format(self.job_test_name(job), testurl)
return ''
def summarize_openqa_jobs(self, jobs):
groups = {}
for job in jobs:
gl = "{!s}@{!s}".format(self.emd(job['group']), self.emd(job['settings']['FLAVOR']))
if gl not in groups:
groupurl = osc.core.makeurl(self.openqa.baseurl, ['tests', 'overview'],
{'version': job['settings']['VERSION'],
'groupid': job['group_id'],
'flavor': job['settings']['FLAVOR'],
'distri': job['settings']['DISTRI'],
'build': job['settings']['BUILD'],
})
groups[gl] = {'title': "__Group [{!s}]({!s})__\n".format(gl, groupurl),
'passed': 0, 'unfinished': 0, 'failed': []}
job_summary = self.summarize_one_openqa_job(job)
if job_summary is None:
groups[gl]['unfinished'] = groups[gl]['unfinished'] + 1
continue
# None vs ''
if not len(job_summary):
groups[gl]['passed'] = groups[gl]['passed'] + 1
continue
# if there is something to report, hold the request
# TODO: what is this ?
# qa_state = QA_FAILED
# gmsg = groups[gl]
groups[gl]['failed'].append(job_summary)
msg = ''
for group in sorted(groups.keys()):
msg += "\n\n" + groups[group]['title']
infos = []
if groups[group]['passed']:
infos.append("{:d} tests passed".format(groups[group]['passed']))
if len(groups[group]['failed']):
infos.append("{:d} tests failed".format(len(groups[group]['failed'])))
if groups[group]['unfinished']:
infos.append("{:d} unfinished tests".format(groups[group]['unfinished']))
msg += "(" + ', '.join(infos) + ")\n"
for fail in groups[group]['failed']:
msg += fail
return msg.rstrip('\n')
def check_one_request(self, req):
try:
jobs, qa_state = self.request_get_openqa_status(req)
self.logger.debug("request %s state %s", req.reqid, qa_state)
msg = None
if qa_state == QA_UNKNOWN:
incident_id = req.to_xml().findall('.action/source')[0].get('project').split(":")[-1]
if not jobs and incident_id not in self.wait_for_build:
msg = "no openQA tests defined"
self.comment_write(state='done', message=msg, request=req, result='accepted')
return True
else:
self.logger.debug("request {} waits for build".format(req.reqid))
elif qa_state == QA_FAILED or qa_state == QA_PASSED:
if qa_state == QA_PASSED:
msg = "openQA tests passed\n"
result = 'accepted'
ret = True
else:
msg = "openQA tests problematic\n"
result = 'declined'
ret = False
msg += self.summarize_openqa_jobs(jobs)
self.comment_write(state='done', message=msg, result=result, request=req)
return ret
elif qa_state == QA_INPROGRESS:
self.logger.info("request %s still in progress", req.reqid)
else:
raise Exception("unknown QA state %d", qa_state)
except Exception:
import traceback
self.logger.error("unhandled exception in openQA Bot")
self.logger.error(traceback.format_exc())
return None
return
def find_obs_request_comment(self, request_id=None, project_name=None):
"""Return previous comments (should be one)."""
comments = self.commentapi.get_comments(request_id=request_id, project_name=project_name)
comment, info = self.commentapi.comment_find(comments, self.bot_name)
if comment:
# we only care for two fields
return {'id': comment['id'], 'revision': info['revision']}
return {}
def check_product_arch(self, job, product_prefix, pmap, arch):
need = False
settings = {'VERSION': pmap['version']}
settings['ARCH'] = arch if arch else 'x86_64'
settings['DISTRI'] = pmap.get('distri', 'sle')
issues = pmap.get('issues', {})
issues['OS_TEST_ISSUES'] = issues.get('OS_TEST_ISSUES', product_prefix)
required_issue = pmap.get('required_issue', False)
for key, prefix in issues.items():
# self.logger.debug("KP {} {}".format(key, prefix) + str(job))
channel = prefix
if arch:
channel += arch
if channel in job['channels']:
settings[key] = str(job['id'])
need = True
if required_issue:
if required_issue not in settings:
need = False
if not need:
return []
product_key = product_prefix
if arch:
product_key += arch
update = self.project_settings[product_key]
update.apiurl = self.apiurl
update.logger = self.logger
posts = []
for j in update.settings(
update.maintenance_project + ':' + str(job['id']),
product_key):
if not job.get('openqa_build'):
job['openqa_build'] = update.get_max_revision(job)
if not job.get('openqa_build'):
self.wait_for_build.add(str(job['id']))
return []
self.incident_repos.setdefault(product_key, dict())[
str(job['id'])] = job.get('openqa_build')
j['BUILD'] += '.' + str(job['openqa_build'])
j.update(settings)
# kGraft jobs can have different version
if 'real_version' in j:
j['VERSION'] = j['real_version']
del j['real_version']
posts.append(j)
return posts
def check_product(self, job, product_prefix):
pmap = self.api_map[product_prefix]
posts = []
if 'archs' in pmap:
for arch in pmap['archs']:
posts += self.check_product_arch(job, product_prefix, pmap, arch)
else:
posts += self.check_product_arch(job, product_prefix, pmap, None)
self.logger.debug("Pmap: {} Posts: {}".format(pmap, posts))
return posts
def incident_openqa_jobs(self, s):
return self.openqa.openqa_request(
'GET', 'jobs',
{
'distri': s['DISTRI'],
'version': s['VERSION'],
'arch': s['ARCH'],
'flavor': s['FLAVOR'],
'build': s['BUILD'],
'scope': 'relevant',
'latest': '1'
})['jobs']
# for SUSE we use mesh, for openSUSE we limit the jobs to open release requests
def check_opensuse_incidents(self):
requests = dict() # collecting unique requests
self.wait_for_build = set()
for prj in self.tgt_repo[self.openqa.baseurl].keys():
for r in self.ids_project(prj, 'maintenance_release'):
requests[r.reqid] = r
# to be stored in settings
issues = dict()
for req in sorted(requests.keys()):
req = requests[req]
types = set([a.type for a in req.actions])
if 'maintenance_release' not in types:
continue
src_prjs = set([a.src_project for a in req.actions])
if len(src_prjs) != 1:
raise Exception("can't handle maintenance_release from different incidents")
build = src_prjs.pop()
incident_id = build.split(':')[-1]
tgt_prjs = set()
for a in req.actions:
prj = a.tgt_project
# ignore e.g. Backports
if prj not in self.project_settings:
continue
issues.setdefault(prj, set()).add(incident_id)
tgt_prjs.add(prj)
self.test_job({'project': build, 'id': incident_id, 'channels': list(tgt_prjs)})
for prj in self.tgt_repo[self.openqa.baseurl].keys():
s = self.tgt_repo[self.openqa.baseurl][prj]['settings']
s['OS_TEST_ISSUES'] = ','.join(sorted(issues.get(prj, set())))
def check_suse_incidents(self):
self.wait_for_build = set()
for inc in requests.get('https://maintenance.suse.de/api/incident/active/').json():
self.logger.info("Incident number: {}".format(inc))
mesh_job = requests.get('https://maintenance.suse.de/api/incident/' + inc).json()
if mesh_job['meta']['state'] in ['final', 'gone']:
continue
# required in mesh_job: project, id, channels
self.test_job(mesh_job['base'])
def test_job(self, mesh_job):
self.logger.debug("Called test_job with: {}".format(mesh_job))
incident_project = str(mesh_job['project'])
try:
comment_info = self.find_obs_request_comment(project_name=incident_project)
except HTTPError as e:
self.logger.debug("Couldn't load comments - {}".format(e))
return
comment_build = str(comment_info.get('revision', ''))
openqa_posts = []
for prod in self.api_map.keys():
self.logger.debug("{} -- product in apimap".format(prod))
openqa_posts += self.check_product(mesh_job, prod)
openqa_jobs = []
for s in openqa_posts:
if 'skip_job' in s:
self.wait_for_build.add(str(mesh_job['id']))
continue
jobs = self.incident_openqa_jobs(s)
# take the project comment as marker for not posting jobs
if not len(jobs) and comment_build != str(mesh_job['openqa_build']):
if self.dryrun:
self.logger.info('WOULD POST:{}'.format(pformat(json.dumps(s, sort_keys=True))))
else:
self.logger.info("Posted: {}".format(pformat(json.dumps(s, sort_keys=True))))
self.openqa.openqa_request('POST', 'isos', data=s, retries=1)
openqa_jobs += self.incident_openqa_jobs(s)
else:
self.logger.info("{} got {}".format(pformat(s), len(jobs)))
openqa_jobs += jobs
self.openqa_jobs[incident_project] = openqa_jobs
if len(openqa_jobs) == 0:
self.logger.debug("No openqa jobs defined")
return
# print openqa_jobs
msg = self.summarize_openqa_jobs(openqa_jobs)
state = 'seen'
result = 'none'
qa_status = self.calculate_qa_status(openqa_jobs)
if qa_status == QA_PASSED:
result = 'accepted'
state = 'done'
if qa_status == QA_FAILED:
result = 'declined'
state = 'done'
self.comment_write(project=str(incident_project), state=state,
result=result, message=msg,
info_extra={'revision': str(mesh_job.get('openqa_build'))})
class ReviewBot(object):
"""
A generic obs request reviewer
Inherit from this class and implement check functions for each action type:
def check_action_<type>(self, req, action):
return (None|True|False)
"""
DEFAULT_REVIEW_MESSAGES = { 'accepted' : 'ok', 'declined': 'review failed' }
REVIEW_CHOICES = ('normal', 'no', 'accept', 'accept-onpass', 'fallback-onfail', 'fallback-always')
COMMENT_MARKER_REGEX = re.compile(r'<!-- (?P<bot>[^ ]+) state=(?P<state>[^ ]+)(?: result=(?P<result>[^ ]+))? -->')
# map of default config entries
config_defaults = {
# list of tuples (prefix, apiurl, submitrequestprefix)
# set this if the obs instance maps another instance into it's
# namespace
'project_namespace_api_map' : [
('openSUSE.org:', 'https://api.opensuse.org', 'obsrq'),
],
}
def __init__(self, apiurl = None, dryrun = False, logger = None, user = None, group = None):
self.apiurl = apiurl
self.ibs = apiurl.startswith('https://api.suse.de')
self.dryrun = dryrun
self.logger = logger
self.review_user = user
self.review_group = group
self.requests = []
self.review_messages = ReviewBot.DEFAULT_REVIEW_MESSAGES
self._review_mode = 'normal'
self.fallback_user = None
self.fallback_group = None
self.comment_api = CommentAPI(self.apiurl)
self.bot_name = self.__class__.__name__
self.only_one_action = False
self.request_default_return = None
self.comment_handler = False
self.override_allow = True
self.override_group_key = '{}-override-group'.format(self.bot_name.lower())
self.load_config()
def _load_config(self, handle = None):
d = self.__class__.config_defaults
y = yaml.safe_load(handle) if handle is not None else {}
return namedtuple('BotConfig', sorted(d.keys()))(*[ y.get(p, d[p]) for p in sorted(d.keys()) ])
def load_config(self, filename = None):
if filename:
with open(filename, 'r') as fh:
self.config = self._load_config(fh)
else:
self.config = self._load_config()
def staging_api(self, project):
if project not in self.staging_apis:
config = Config(project)
self.staging_apis[project] = StagingAPI(self.apiurl, project)
config.apply_remote(self.staging_apis[project])
self.staging_config[project] = conf.config[project].copy()
return self.staging_apis[project]
@property
def review_mode(self):
return self._review_mode
@review_mode.setter
def review_mode(self, value):
if value not in self.REVIEW_CHOICES:
raise Exception("invalid review option: %s"%value)
self._review_mode = value
def set_request_ids(self, ids):
for rqid in ids:
u = osc.core.makeurl(self.apiurl, [ 'request', rqid ], { 'withfullhistory' : '1' })
r = osc.core.http_GET(u)
root = ET.parse(r).getroot()
req = osc.core.Request()
req.read(root)
self.requests.append(req)
# function called before requests are reviewed
def prepare_review(self):
pass
def check_requests(self):
self.staging_apis = {}
self.staging_config = {}
# give implementations a chance to do something before single requests
self.prepare_review()
for req in self.requests:
self.logger.info("checking %s"%req.reqid)
self.request = req
override = self.request_override_check(req)
if override is not None:
good = override
else:
good = self.check_one_request(req)
if self.review_mode == 'no':
good = None
elif self.review_mode == 'accept':
good = True
if good is None:
self.logger.info("%s ignored"%req.reqid)
elif good:
self._set_review(req, 'accepted')
elif self.review_mode != 'accept-onpass':
self._set_review(req, 'declined')
@memoize(session=True)
def request_override_check_users(self, project):
"""Determine users allowed to override review in a comment command."""
self.staging_api(project)
config = self.staging_config[project]
users = []
group = config.get('staging-group')
if group:
users += group_members(self.apiurl, group)
if self.override_group_key:
override_group = config.get(self.override_group_key)
if override_group:
users += group_members(self.apiurl, override_group)
return users
def request_override_check(self, request):
"""Check for a comment command requesting review override."""
if not self.override_allow:
return None
comments = self.comment_api.get_comments(request_id=request.reqid)
users = self.request_override_check_users(request.actions[0].tgt_project)
for args, who in self.comment_api.command_find(
comments, self.review_user, 'override', users):
message = 'overridden by {}'.format(who)
override = args[1] or None
if override == 'accept':
self.review_messages['accepted'] = message
return True
if override == 'decline':
self.review_messages['declined'] = message
return False
def _set_review(self, req, state):
doit = self.can_accept_review(req.reqid)
if doit is None:
self.logger.info("can't change state, %s does not have the reviewer"%(req.reqid))
newstate = state
by_user = self.fallback_user
by_group = self.fallback_group
msg = self.review_messages[state] if state in self.review_messages else state
self.logger.info("%s %s: %s"%(req.reqid, state, msg))
if state == 'declined':
if self.review_mode == 'fallback-onfail':
self.logger.info("%s needs fallback reviewer"%req.reqid)
self.add_review(req, by_group=by_group, by_user=by_user, msg="Automated review failed. Needs fallback reviewer.")
newstate = 'accepted'
elif self.review_mode == 'fallback-always':
self.add_review(req, by_group=by_group, by_user=by_user, msg='Adding fallback reviewer')
if doit == True:
self.logger.debug("setting %s to %s"%(req.reqid, state))
if not self.dryrun:
osc.core.change_review_state(apiurl = self.apiurl,
reqid = req.reqid, newstate = newstate,
by_group=self.review_group,
by_user=self.review_user, message=msg)
else:
self.logger.debug("%s review not changed"%(req.reqid))
# allow_duplicate=True should only be used if it makes sense to force a
# re-review in a scenario where the bot adding the review will rerun.
# Normally a declined review will automatically be reopened along with the
# request and any other bot reviews already added will not be touched unless
# the issuing bot is rerun which does not fit normal workflow.
def add_review(self, req, by_group=None, by_user=None, by_project=None, by_package=None,
msg=None, allow_duplicate=False):
query = {
'cmd': 'addreview'
}
if by_group:
query['by_group'] = by_group
elif by_user:
query['by_user'] = by_user
elif by_project:
query['by_project'] = by_project
if by_package:
query['by_package'] = by_package
else:
raise osc.oscerr.WrongArgs("missing by_*")
for r in req.reviews:
if (r.by_group == by_group and
r.by_project == by_project and
r.by_package == by_package and
r.by_user == by_user and
# Only duplicate when allow_duplicate and state != new.
(not allow_duplicate or r.state == 'new')):
del query['cmd']
self.logger.debug('skipped adding duplicate review for {}'.format(
'/'.join(query.values())))
return
u = osc.core.makeurl(self.apiurl, ['request', req.reqid], query)
if self.dryrun:
self.logger.info('POST %s' % u)
return
r = osc.core.http_POST(u, data=msg)
code = ET.parse(r).getroot().attrib['code']
if code != 'ok':
raise Exception('non-ok return code: {}'.format(code))
def check_one_request(self, req):
"""
check all actions in one request.
calls helper functions for each action type
return None if nothing to do, True to accept, False to reject
"""
# Copy original values to revert changes made to them.
self.review_messages = self.DEFAULT_REVIEW_MESSAGES.copy()
if self.only_one_action and len(req.actions) != 1:
self.review_messages['declined'] = 'Only one action per request'
return False
if self.comment_handler is not False:
self.comment_handler_add()
overall = None
for a in req.actions:
fn = 'check_action_%s'%a.type
if not hasattr(self, fn):
fn = 'check_action__default'
func = getattr(self, fn)
ret = func(req, a)
if ret == False or overall is None and ret is not None:
overall = ret
return overall
@staticmethod
def _is_patchinfo(pkgname):
return pkgname == 'patchinfo' or pkgname.startswith('patchinfo.')
def check_action_maintenance_incident(self, req, a):
dst_package = a.src_package
# Ignoring patchinfo package for checking
if self._is_patchinfo(a.src_package):
self.logger.info("package is patchinfo, ignoring")
return None
# dirty obs crap
if a.tgt_releaseproject is not None:
ugly_suffix = '.'+a.tgt_releaseproject.replace(':', '_')
if dst_package.endswith(ugly_suffix):
dst_package = dst_package[:-len(ugly_suffix)]
return self.check_source_submission(a.src_project, a.src_package, a.src_rev, a.tgt_releaseproject, dst_package)
def check_action_maintenance_release(self, req, a):
pkgname = a.src_package
if self._is_patchinfo(pkgname):
return None
linkpkg = self._get_linktarget_self(a.src_project, pkgname)
if linkpkg is not None:
pkgname = linkpkg
# packages in maintenance have links to the target. Use that
# to find the real package name
(linkprj, linkpkg) = self._get_linktarget(a.src_project, pkgname)
if linkpkg is None or linkprj is None or linkprj != a.tgt_project:
self.logger.error("%s/%s is not a link to %s"%(a.src_project, pkgname, a.tgt_project))
return False
else:
pkgname = linkpkg
return self.check_source_submission(a.src_project, a.src_package, None, a.tgt_project, pkgname)
def check_action_submit(self, req, a):
return self.check_source_submission(a.src_project, a.src_package, a.src_rev, a.tgt_project, a.tgt_package)
def check_action__default(self, req, a):
# Disable any comment handler to avoid making a comment even if
# comment_write() is called by another bot wrapping __default().
self.comment_handler_remove()
message = 'unhandled request type {}'.format(a.type)
self.logger.error(message)
self.review_messages['accepted'] += ': ' + message
return self.request_default_return
def check_source_submission(self, src_project, src_package, src_rev, target_project, target_package):
""" default implemention does nothing """
self.logger.info("%s/%s@%s -> %s/%s"%(src_project, src_package, src_rev, target_project, target_package))
return None
@staticmethod
@memoize(session=True)
def _get_sourceinfo(apiurl, project, package, rev=None):
query = { 'view': 'info' }
if rev is not None:
query['rev'] = rev
url = osc.core.makeurl(apiurl, ('source', project, package), query=query)
try:
return ET.parse(osc.core.http_GET(url)).getroot()
except (urllib2.HTTPError, urllib2.URLError):
return None
def get_originproject(self, project, package, rev=None):
root = ReviewBot._get_sourceinfo(self.apiurl, project, package, rev)
if root is None:
return None
originproject = root.find('originproject')
if originproject is not None:
return originproject.text
return None
def get_sourceinfo(self, project, package, rev=None):
root = ReviewBot._get_sourceinfo(self.apiurl, project, package, rev)
if root is None:
return None
props = ('package', 'rev', 'vrev', 'srcmd5', 'lsrcmd5', 'verifymd5')
return namedtuple('SourceInfo', props)(*[ root.get(p) for p in props ])
# TODO: what if there is more than _link?
def _get_linktarget_self(self, src_project, src_package):
""" if it's a link to a package in the same project return the name of the package"""
prj, pkg = self._get_linktarget(src_project, src_package)
if prj is None or prj == src_project:
return pkg
def _get_linktarget(self, src_project, src_package):
query = {}
url = osc.core.makeurl(self.apiurl, ('source', src_project, src_package), query=query)
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
except urllib2.HTTPError:
return (None, None)
if root is not None:
linkinfo = root.find("linkinfo")
if linkinfo is not None:
return (linkinfo.get('project'), linkinfo.get('package'))
return (None, None)
def _has_open_review_by(self, root, by_what, reviewer):
states = set([review.get('state') for review in root.findall('review') if review.get(by_what) == reviewer])
if not states:
return None
elif 'new' in states:
return True
return False
def can_accept_review(self, request_id):
"""return True if there is a new review for the specified reviewer"""
states = set()
url = osc.core.makeurl(self.apiurl, ('request', str(request_id)))
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
if self.review_user and self._has_open_review_by(root, 'by_user', self.review_user):
return True
if self.review_group and self._has_open_review_by(root, 'by_group', self.review_group):
return True
except urllib2.HTTPError as e:
print('ERROR in URL %s [%s]' % (url, e))
return False
def set_request_ids_search_review(self):
review = None
if self.review_user:
review = "@by_user='******' and @state='new'" % self.review_user
if self.review_group:
review = osc.core.xpath_join(review, "@by_group='%s' and @state='new'" % self.review_group)
url = osc.core.makeurl(self.apiurl, ('search', 'request'), { 'match': "state/@name='review' and review[%s]" % review, 'withfullhistory': 1 } )
root = ET.parse(osc.core.http_GET(url)).getroot()
self.requests = []
for request in root.findall('request'):
req = osc.core.Request()
req.read(request)
self.requests.append(req)
# also used by openqabot
def ids_project(self, project, typename):
url = osc.core.makeurl(self.apiurl, ('search', 'request'),
{ 'match': "(state/@name='review' or state/@name='new') and (action/target/@project='%s' and action/@type='%s')" % (project, typename),
'withfullhistory': 1 })
root = ET.parse(osc.core.http_GET(url)).getroot()
ret = []
for request in root.findall('request'):
req = osc.core.Request()
req.read(request)
ret.append(req)
return ret
def set_request_ids_project(self, project, typename):
self.requests = self.ids_project(project, typename)
def comment_handler_add(self, level=logging.INFO):
"""Add handler to start recording log messages for comment."""
self.comment_handler = CommentFromLogHandler(level)
self.logger.addHandler(self.comment_handler)
def comment_handler_remove(self):
self.logger.removeHandler(self.comment_handler)
def comment_handler_lines_deduplicate(self):
self.comment_handler.lines = list(OrderedDict.fromkeys(self.comment_handler.lines))
def comment_write(self, state='done', result=None, project=None, package=None,
request=None, message=None, identical=False, only_replace=False,
info_extra=None, info_extra_identical=True, bot_name_suffix=None):
"""Write comment if not similar to previous comment and replace old one.
The state, result, and info_extra (dict) are combined to create the info
that is passed to CommentAPI methods for creating a marker and finding
previous comments. self.bot_name, which defaults to class, will be used
as the primary matching key. When info_extra_identical is set to False
info_extra will not be included when finding previous comments to
compare message against.
A comment from the same bot will be replaced when a new comment is
written. The only_replace flag will restrict to only writing a comment
if a prior one is being replaced. This can be useful for writing a final
comment that indicates a change from previous uncompleted state, but
only makes sense to post if a prior comment was posted.
The project, package, and request variables control where the comment is
placed. If no value is given the default is the request being reviewed.
If no message is provided the content will be extracted from
self.comment_handler.line which is provided by CommentFromLogHandler. To
use this call comment_handler_add() at the point which messages should
start being collected. Alternatively the self.comment_handler setting
may be set to True to automatically set one on each request.
The previous comment body line count is compared to see if too similar
to bother posting another comment which is useful for avoiding
re-posting comments that contain irrelevant minor changes. To force an
exact match use the identical flag to replace any non-identical
comment body.
"""
if project:
kwargs = {'project_name': project}
if package:
kwargs['package_name'] = package
else:
if request is None:
request = self.request
kwargs = {'request_id': request.reqid}
debug_key = '/'.join(kwargs.values())
if message is None:
if not len(self.comment_handler.lines):
self.logger.debug('skipping empty comment for {}'.format(debug_key))
return
message = '\n\n'.join(self.comment_handler.lines)
bot_name = self.bot_name
if bot_name_suffix:
bot_name = '::'.join([bot_name, bot_name_suffix])
info = {'state': state, 'result': result}
if info_extra and info_extra_identical:
info.update(info_extra)
comments = self.comment_api.get_comments(**kwargs)
comment, _ = self.comment_api.comment_find(comments, bot_name, info)
if info_extra and not info_extra_identical:
# Add info_extra once comment has already been matched.
info.update(info_extra)
message = self.comment_api.add_marker(message, bot_name, info)
message = self.comment_api.truncate(message.strip())
if (comment is not None and
((identical and
# Remove marker from comments since handled during comment_find().
self.comment_api.remove_marker(comment['comment']) ==
self.comment_api.remove_marker(message)) or
(not identical and comment['comment'].count('\n') == message.count('\n')))
):
# Assume same state/result and number of lines in message is duplicate.
self.logger.debug('previous comment too similar on {}'.format(debug_key))
return
if comment is None:
self.logger.debug('broadening search to include any state on {}'.format(debug_key))
comment, _ = self.comment_api.comment_find(comments, bot_name)
if comment is not None:
self.logger.debug('removing previous comment on {}'.format(debug_key))
if not self.dryrun:
self.comment_api.delete(comment['id'])
elif only_replace:
self.logger.debug('no previous comment to replace on {}'.format(debug_key))
return
self.logger.debug('adding comment to {}: {}'.format(debug_key, message))
if not self.dryrun:
self.comment_api.add_comment(comment=message, **kwargs)
self.comment_handler_remove()
class TestAccept(unittest.TestCase):
def setup_wf(self, description=''):
wf = OBSLocal.FactoryWorkflow()
wf.setup_rings()
self.c_api = CommentAPI(wf.api.apiurl)
staging_b = wf.create_staging('B', freeze=True)
self.prj = staging_b.name
self.winerq = wf.create_submit_request('devel:wine', 'wine', text='Hallo World', description=description)
self.assertEqual(True, SelectCommand(wf.api, self.prj).perform(['wine']))
self.comments = self.c_api.get_comments(project_name=self.prj)
wf.create_attribute_type('OSRT', 'ProductVersion', 1)
return wf
def test_accept_comments(self):
wf = self.setup_wf()
self.assertEqual(True, AcceptCommand(wf.api).accept_all(['B']))
# Comments are cleared up
accepted_comments = self.c_api.get_comments(project_name=self.prj)
self.assertEqual(len(accepted_comments), 0)
def test_accept_bugowners(self):
wf = self.setup_wf(description="bugowner: group:factory-staging")
self.assertEqual(True, AcceptCommand(wf.api).accept_all(['B']))
# we expect that the requests increase by 1 - to avoid a full search
request = get_request(wf.apiurl, str(int(self.winerq.reqid) + 1))
# it's in review because this is a staging workflow
self.assertEqual(request.state.name, 'review')
exp = '<action type="set_bugowner">\n <target project="openSUSE:Factory" ' + \
'package="wine" />\n <group name="factory-staging" />\n</action>'
self.assertEqual(request.actions[0].to_str(), exp)
def test_accept_final_comment(self):
wf = self.setup_wf()
# snipe out cleanup to see the comments before the final countdown
wf.api.staging_deactivate = MagicMock(return_value=True)
self.assertEqual(True, AcceptCommand(wf.api).accept_all(['B']))
comments = self.c_api.get_comments(project_name=self.prj)
self.assertGreater(len(comments), len(self.comments))
# check which id was added
new_id = (set(comments.keys()) - set(self.comments.keys())).pop()
comment = comments[new_id]['comment']
ncomment = 'Project "{}" accepted. '.format(self.prj)
ncomment += "The following packages have been submitted to openSUSE:Factory: wine."
self.assertEqual(ncomment, comment)
def test_accept_new_multibuild_package(self):
wf = self.setup_wf()
staging = wf.create_staging('A', freeze=True)
project = wf.create_project('devel:gcc')
package = OBSLocal.Package(name='gcc9', project=project)
package.create_commit(filename='gcc9.spec')
package.create_commit(filename='gcc9-tests.spec')
package.create_commit('<multibuild><flavor>gcc9-tests.spec</flavor></multibuild>', filename='_multibuild')
wf.submit_package(package)
SelectCommand(wf.api, staging.name).perform(['gcc9'])
ac = AcceptCommand(wf.api)
self.assertEqual(True, ac.accept_all(['A'], True))
# no stale links
self.assertEqual([], package_list(wf.apiurl, staging.name))
self.assertEqual(['gcc9', 'wine'], package_list(wf.apiurl, wf.project))
def test_accept_new_multispec_package(self):
wf = self.setup_wf()
staging = wf.create_staging('A', freeze=True)
project = wf.create_project('devel:gcc')
package = OBSLocal.Package(name='gcc9', project=project)
package.create_commit(filename='gcc9.spec')
package.create_commit(filename='gcc9-tests.spec')
wf.submit_package(package)
SelectCommand(wf.api, staging.name).perform(['gcc9'])
ac = AcceptCommand(wf.api)
self.assertEqual(True, ac.accept_all(['A'], True))
# no stale links
self.assertEqual([], package_list(wf.apiurl, staging.name))
self.assertEqual(['gcc9', 'gcc9-tests', 'wine'], package_list(wf.apiurl, wf.project))
def test_accept_switch_to_multibuild_package(self):
wf = self.setup_wf()
staging = wf.create_staging('A', freeze=True)
tpackage = wf.create_package('target', 'gcc9')
tpackage.create_commit(filename='gcc9.spec')
tpackage.create_commit(filename='gcc9-tests.spec')
lpackage = wf.create_package('target', 'gcc9-tests')
lpackage.create_commit('<link package="gcc9" cicount="copy" />', filename='_link')
project = wf.create_project('devel:gcc')
package = OBSLocal.Package(name='gcc9', project=project)
package.create_commit(filename='gcc9.spec')
package.create_commit(filename='gcc9-tests.spec')
package.create_commit('<multibuild><flavor>gcc9-tests.spec</flavor></multibuild>', filename='_multibuild')
wf.submit_package(package)
SelectCommand(wf.api, staging.name).perform(['gcc9'])
ac = AcceptCommand(wf.api)
self.assertEqual(True, ac.accept_all(['A'], True))
# no stale links
self.assertEqual([], package_list(wf.apiurl, staging.name))
self.assertEqual(['gcc9', 'wine'], package_list(wf.apiurl, wf.project))
class ReviewBot(object):
"""
A generic obs request reviewer
Inherit from this class and implement check functions for each action type:
def check_action_<type>(self, req, action):
return (None|True|False)
"""
DEFAULT_REVIEW_MESSAGES = { 'accepted' : 'ok', 'declined': 'review failed' }
REVIEW_CHOICES = ('normal', 'no', 'accept', 'accept-onpass', 'fallback-onfail', 'fallback-always')
COMMENT_MARKER_REGEX = re.compile(r'<!-- (?P<bot>[^ ]+) state=(?P<state>[^ ]+)(?: result=(?P<result>[^ ]+))? -->')
# map of default config entries
config_defaults = {
# list of tuples (prefix, apiurl, submitrequestprefix)
# set this if the obs instance maps another instance into it's
# namespace
'project_namespace_api_map' : [
('openSUSE.org:', 'https://api.opensuse.org', 'obsrq'),
],
}
def __init__(self, apiurl = None, dryrun = False, logger = None, user = None, group = None):
self.apiurl = apiurl
self.ibs = apiurl.startswith('https://api.suse.de')
self.dryrun = dryrun
self.logger = logger
self.review_user = user
self.review_group = group
self.requests = []
self.review_messages = ReviewBot.DEFAULT_REVIEW_MESSAGES
self._review_mode = 'normal'
self.fallback_user = None
self.fallback_group = None
self.comment_api = CommentAPI(self.apiurl)
self.bot_name = self.__class__.__name__
self.only_one_action = False
self.request_default_return = None
self.comment_handler = False
self.override_allow = True
self.override_group_key = '{}-override-group'.format(self.bot_name.lower())
self.lookup = PackageLookup(self.apiurl)
self.load_config()
def _load_config(self, handle = None):
d = self.__class__.config_defaults
y = yaml.safe_load(handle) if handle is not None else {}
return namedtuple('BotConfig', sorted(d.keys()))(*[ y.get(p, d[p]) for p in sorted(d.keys()) ])
def load_config(self, filename = None):
if filename:
with open(filename, 'r') as fh:
self.config = self._load_config(fh)
else:
self.config = self._load_config()
def staging_api(self, project):
# Allow for the Staging subproject to be passed directly from config
# which should be stripped before initializing StagingAPI. This allows
# for NonFree subproject to utilize StagingAPI for main project.
if project.endswith(':Staging'):
project = project[:-8]
if project not in self.staging_apis:
Config.get(self.apiurl, project)
self.staging_apis[project] = StagingAPI(self.apiurl, project)
return self.staging_apis[project]
@property
def review_mode(self):
return self._review_mode
@review_mode.setter
def review_mode(self, value):
if value not in self.REVIEW_CHOICES:
raise Exception("invalid review option: %s"%value)
self._review_mode = value
def set_request_ids(self, ids):
for rqid in ids:
u = osc.core.makeurl(self.apiurl, [ 'request', rqid ], { 'withfullhistory' : '1' })
r = osc.core.http_GET(u)
root = ET.parse(r).getroot()
req = osc.core.Request()
req.read(root)
self.requests.append(req)
# function called before requests are reviewed
def prepare_review(self):
pass
def check_requests(self):
self.staging_apis = {}
# give implementations a chance to do something before single requests
self.prepare_review()
for req in self.requests:
self.logger.info("checking %s"%req.reqid)
self.request = req
override = self.request_override_check(req)
if override is not None:
good = override
else:
try:
good = self.check_one_request(req)
except:
good = None
import traceback
traceback.print_exc()
if self.review_mode == 'no':
good = None
elif self.review_mode == 'accept':
good = True
if good is None:
self.logger.info("%s ignored"%req.reqid)
elif good:
self._set_review(req, 'accepted')
elif self.review_mode != 'accept-onpass':
self._set_review(req, 'declined')
@memoize(session=True)
def request_override_check_users(self, project):
"""Determine users allowed to override review in a comment command."""
config = Config.get(self.apiurl, project)
users = []
group = config.get('staging-group')
if group:
users += group_members(self.apiurl, group)
if self.override_group_key:
override_group = config.get(self.override_group_key)
if override_group:
users += group_members(self.apiurl, override_group)
return users
def request_override_check(self, request, force=False):
"""Check for a comment command requesting review override."""
if not force and not self.override_allow:
return None
comments = self.comment_api.get_comments(request_id=request.reqid)
users = self.request_override_check_users(request.actions[0].tgt_project)
for args, who in self.comment_api.command_find(
comments, self.review_user, 'override', users):
message = 'overridden by {}'.format(who)
override = args[1] if len(args) >= 2 else 'accept'
if override == 'accept':
self.review_messages['accepted'] = message
return True
if override == 'decline':
self.review_messages['declined'] = message
return False
def _set_review(self, req, state):
doit = self.can_accept_review(req.reqid)
if doit is None:
self.logger.info("can't change state, %s does not have the reviewer"%(req.reqid))
newstate = state
by_user = self.fallback_user
by_group = self.fallback_group
msg = self.review_messages[state] if state in self.review_messages else state
self.logger.info("%s %s: %s"%(req.reqid, state, msg))
if state == 'declined':
if self.review_mode == 'fallback-onfail':
self.logger.info("%s needs fallback reviewer"%req.reqid)
self.add_review(req, by_group=by_group, by_user=by_user, msg="Automated review failed. Needs fallback reviewer.")
newstate = 'accepted'
elif self.review_mode == 'fallback-always':
self.add_review(req, by_group=by_group, by_user=by_user, msg='Adding fallback reviewer')
if doit == True:
self.logger.debug("setting %s to %s"%(req.reqid, state))
if not self.dryrun:
osc.core.change_review_state(apiurl = self.apiurl,
reqid = req.reqid, newstate = newstate,
by_group=self.review_group,
by_user=self.review_user, message=msg)
else:
self.logger.debug("%s review not changed"%(req.reqid))
# allow_duplicate=True should only be used if it makes sense to force a
# re-review in a scenario where the bot adding the review will rerun.
# Normally a declined review will automatically be reopened along with the
# request and any other bot reviews already added will not be touched unless
# the issuing bot is rerun which does not fit normal workflow.
def add_review(self, req, by_group=None, by_user=None, by_project=None, by_package=None,
msg=None, allow_duplicate=False):
query = {
'cmd': 'addreview'
}
if by_group:
query['by_group'] = by_group
elif by_user:
query['by_user'] = by_user
elif by_project:
query['by_project'] = by_project
if by_package:
query['by_package'] = by_package
else:
raise osc.oscerr.WrongArgs("missing by_*")
for r in req.reviews:
if (r.by_group == by_group and
r.by_project == by_project and
r.by_package == by_package and
r.by_user == by_user and
# Only duplicate when allow_duplicate and state != new.
(not allow_duplicate or r.state == 'new')):
del query['cmd']
self.logger.debug('skipped adding duplicate review for {}'.format(
'/'.join(query.values())))
return
u = osc.core.makeurl(self.apiurl, ['request', req.reqid], query)
if self.dryrun:
self.logger.info('POST %s' % u)
return
r = osc.core.http_POST(u, data=msg)
code = ET.parse(r).getroot().attrib['code']
if code != 'ok':
raise Exception('non-ok return code: {}'.format(code))
def devel_project_review_add(self, request, project, package, message='adding devel project review'):
devel_project, devel_package = devel_project_fallback(self.apiurl, project, package)
if not devel_project:
self.logger.warning('no devel project found for {}/{}'.format(project, package))
return False
try:
self.add_review(request, by_project=devel_project, by_package=devel_package, msg=message)
except HTTPError as e:
# could happen when the bot is not actually a reviewer and has no permissions
if e.code != 403:
raise e
self.logger.error('failed to add devel project review for {}/{}'.format(devel_project, devel_package))
return False
return True
def devel_project_review_ensure(self, request, project, package, message='submitter not devel maintainer'):
if not self.devel_project_review_needed(request, project, package):
self.logger.debug('devel project review not needed')
return True
return self.devel_project_review_add(request, project, package, message)
def devel_project_review_needed(self, request, project, package):
author = request.get_creator()
maintainers = set(maintainers_get(self.apiurl, project, package))
if author in maintainers:
return False
# Carried over from maintbot, but seems haphazard.
for review in request.reviews:
if review.by_user in maintainers:
return False
return True
def check_one_request(self, req):
"""
check all actions in one request.
calls helper functions for each action type
return None if nothing to do, True to accept, False to reject
"""
# Copy original values to revert changes made to them.
self.review_messages = self.DEFAULT_REVIEW_MESSAGES.copy()
if self.only_one_action and len(req.actions) != 1:
self.review_messages['declined'] = 'Only one action per request supported'
return False
if self.comment_handler is not False:
self.comment_handler_add()
overall = True
for a in req.actions:
# Store in-case sub-classes need direct access to original values.
self.action = a
func = getattr(self, self.action_method(a))
ret = func(req, a)
# In the case of multiple actions take the "lowest" result where the
# order from lowest to highest is: False, None, True.
if overall is not False:
if ((overall is True and ret is not True) or
(overall is None and ret is False)):
overall = ret
return overall
def action_method(self, action):
method_prefix = 'check_action'
method_type = action.type
method_suffix = None
if method_type == 'delete':
method_suffix = 'project'
if action.tgt_package is not None:
method_suffix = 'package'
elif action.tgt_repository is not None:
method_suffix = 'repository'
if method_suffix:
method = '_'.join([method_prefix, method_type, method_suffix])
if hasattr(self, method):
return method
method = '_'.join([method_prefix, method_type])
if hasattr(self, method):
return method
method_type = '_default'
return '_'.join([method_prefix, method_type])
@staticmethod
def _is_patchinfo(pkgname):
return pkgname == 'patchinfo' or pkgname.startswith('patchinfo.')
def check_action_maintenance_incident(self, req, a):
if self._is_patchinfo(a.src_package):
self.logger.debug('ignoring patchinfo action')
return True
# Duplicate src_package as tgt_package since prior to assignment to a
# specific incident project there is no target package (odd API). After
# assignment it is still assumed the target will match the source. Since
# the ultimate goal is the tgt_releaseproject the incident is treated
# similar to staging in that the intermediate result is not the final
# and thus the true target project (ex. openSUSE:Maintenance) is not
# used for check_source_submission().
tgt_package = a.src_package
if a.tgt_releaseproject is not None:
suffix = '.' + a.tgt_releaseproject.replace(':', '_')
if tgt_package.endswith(suffix):
tgt_package = tgt_package[:-len(suffix)]
# Note tgt_releaseproject (product) instead of tgt_project (maintenance).
return self.check_source_submission(a.src_project, a.src_package, a.src_rev,
a.tgt_releaseproject, tgt_package)
def check_action_maintenance_release(self, req, a):
pkgname = a.src_package
if self._is_patchinfo(pkgname):
self.logger.debug('ignoring patchinfo action')
return True
linkpkg = self._get_linktarget_self(a.src_project, pkgname)
if linkpkg is not None:
pkgname = linkpkg
# packages in maintenance have links to the target. Use that
# to find the real package name
(linkprj, linkpkg) = self._get_linktarget(a.src_project, pkgname)
if linkpkg is None or linkprj is None or linkprj != a.tgt_project:
self.logger.warning("%s/%s is not a link to %s"%(a.src_project, pkgname, a.tgt_project))
return self.check_source_submission(a.src_project, a.src_package, a.src_rev, a.tgt_project, a.tgt_package)
else:
pkgname = linkpkg
return self.check_source_submission(a.src_project, a.src_package, None, a.tgt_project, pkgname)
def check_action_submit(self, req, a):
return self.check_source_submission(a.src_project, a.src_package, a.src_rev, a.tgt_project, a.tgt_package)
def check_action__default(self, req, a):
# Disable any comment handler to avoid making a comment even if
# comment_write() is called by another bot wrapping __default().
self.comment_handler_remove()
message = 'unhandled request type {}'.format(a.type)
self.logger.error(message)
self.review_messages['accepted'] += ': ' + message
return self.request_default_return
def check_source_submission(self, src_project, src_package, src_rev, target_project, target_package):
""" default implemention does nothing """
self.logger.info("%s/%s@%s -> %s/%s"%(src_project, src_package, src_rev, target_project, target_package))
return None
@staticmethod
@memoize(session=True)
def _get_sourceinfo(apiurl, project, package, rev=None):
query = { 'view': 'info' }
if rev is not None:
query['rev'] = rev
url = osc.core.makeurl(apiurl, ('source', project, package), query=query)
try:
return ET.parse(osc.core.http_GET(url)).getroot()
except (HTTPError, URLError):
return None
def get_originproject(self, project, package, rev=None):
root = ReviewBot._get_sourceinfo(self.apiurl, project, package, rev)
if root is None:
return None
originproject = root.find('originproject')
if originproject is not None:
return originproject.text
return None
def get_sourceinfo(self, project, package, rev=None):
root = ReviewBot._get_sourceinfo(self.apiurl, project, package, rev)
if root is None:
return None
props = ('package', 'rev', 'vrev', 'srcmd5', 'lsrcmd5', 'verifymd5')
return namedtuple('SourceInfo', props)(*[ root.get(p) for p in props ])
# TODO: what if there is more than _link?
def _get_linktarget_self(self, src_project, src_package):
""" if it's a link to a package in the same project return the name of the package"""
prj, pkg = self._get_linktarget(src_project, src_package)
if prj is None or prj == src_project:
return pkg
def _get_linktarget(self, src_project, src_package):
query = {}
url = osc.core.makeurl(self.apiurl, ('source', src_project, src_package), query=query)
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
except HTTPError:
return (None, None)
if root is not None:
linkinfo = root.find("linkinfo")
if linkinfo is not None:
return (linkinfo.get('project'), linkinfo.get('package'))
return (None, None)
def _has_open_review_by(self, root, by_what, reviewer):
states = set([review.get('state') for review in root.findall('review') if review.get(by_what) == reviewer])
if not states:
return None
elif 'new' in states:
return True
return False
def can_accept_review(self, request_id):
"""return True if there is a new review for the specified reviewer"""
states = set()
url = osc.core.makeurl(self.apiurl, ('request', str(request_id)))
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
if self.review_user and self._has_open_review_by(root, 'by_user', self.review_user):
return True
if self.review_group and self._has_open_review_by(root, 'by_group', self.review_group):
return True
except HTTPError as e:
print('ERROR in URL %s [%s]' % (url, e))
return False
def set_request_ids_search_review(self):
review = None
if self.review_user:
review = "@by_user='******' and @state='new'" % self.review_user
if self.review_group:
review = osc.core.xpath_join(review, "@by_group='%s' and @state='new'" % self.review_group)
url = osc.core.makeurl(self.apiurl, ('search', 'request'), { 'match': "state/@name='review' and review[%s]" % review, 'withfullhistory': 1 } )
root = ET.parse(osc.core.http_GET(url)).getroot()
self.requests = []
for request in root.findall('request'):
req = osc.core.Request()
req.read(request)
self.requests.append(req)
# also used by openqabot
def ids_project(self, project, typename):
url = osc.core.makeurl(self.apiurl, ('search', 'request'),
{ 'match': "(state/@name='review' or state/@name='new') and (action/target/@project='%s' and action/@type='%s')" % (project, typename),
'withfullhistory': 1 })
root = ET.parse(osc.core.http_GET(url)).getroot()
ret = []
for request in root.findall('request'):
req = osc.core.Request()
req.read(request)
ret.append(req)
return ret
def set_request_ids_project(self, project, typename):
self.requests = self.ids_project(project, typename)
def comment_handler_add(self, level=logging.INFO):
"""Add handler to start recording log messages for comment."""
self.comment_handler = CommentFromLogHandler(level)
self.logger.addHandler(self.comment_handler)
def comment_handler_remove(self):
self.logger.removeHandler(self.comment_handler)
def comment_handler_lines_deduplicate(self):
self.comment_handler.lines = list(OrderedDict.fromkeys(self.comment_handler.lines))
def comment_write(self, state='done', result=None, project=None, package=None,
request=None, message=None, identical=False, only_replace=False,
info_extra=None, info_extra_identical=True, bot_name_suffix=None):
"""Write comment if not similar to previous comment and replace old one.
The state, result, and info_extra (dict) are combined to create the info
that is passed to CommentAPI methods for creating a marker and finding
previous comments. self.bot_name, which defaults to class, will be used
as the primary matching key. When info_extra_identical is set to False
info_extra will not be included when finding previous comments to
compare message against.
A comment from the same bot will be replaced when a new comment is
written. The only_replace flag will restrict to only writing a comment
if a prior one is being replaced. This can be useful for writing a final
comment that indicates a change from previous uncompleted state, but
only makes sense to post if a prior comment was posted.
The project, package, and request variables control where the comment is
placed. If no value is given the default is the request being reviewed.
If no message is provided the content will be extracted from
self.comment_handler.line which is provided by CommentFromLogHandler. To
use this call comment_handler_add() at the point which messages should
start being collected. Alternatively the self.comment_handler setting
may be set to True to automatically set one on each request.
The previous comment body line count is compared to see if too similar
to bother posting another comment which is useful for avoiding
re-posting comments that contain irrelevant minor changes. To force an
exact match use the identical flag to replace any non-identical
comment body.
"""
if project:
kwargs = {'project_name': project}
if package:
kwargs['package_name'] = package
else:
if request is None:
request = self.request
kwargs = {'request_id': request.reqid}
debug_key = '/'.join(kwargs.values())
if message is None:
if not len(self.comment_handler.lines):
self.logger.debug('skipping empty comment for {}'.format(debug_key))
return
message = '\n\n'.join(self.comment_handler.lines)
bot_name = self.bot_name
if bot_name_suffix:
bot_name = '::'.join([bot_name, bot_name_suffix])
info = {'state': state, 'result': result}
if info_extra and info_extra_identical:
info.update(info_extra)
comments = self.comment_api.get_comments(**kwargs)
comment, _ = self.comment_api.comment_find(comments, bot_name, info)
if info_extra and not info_extra_identical:
# Add info_extra once comment has already been matched.
info.update(info_extra)
message = self.comment_api.add_marker(message, bot_name, info)
message = self.comment_api.truncate(message.strip())
if (comment is not None and
((identical and
# Remove marker from comments since handled during comment_find().
self.comment_api.remove_marker(comment['comment']) ==
self.comment_api.remove_marker(message)) or
(not identical and comment['comment'].count('\n') == message.count('\n')))
):
# Assume same state/result and number of lines in message is duplicate.
self.logger.debug('previous comment too similar on {}'.format(debug_key))
return
if comment is None:
self.logger.debug('broadening search to include any state on {}'.format(debug_key))
comment, _ = self.comment_api.comment_find(comments, bot_name)
if comment is not None:
self.logger.debug('removing previous comment on {}'.format(debug_key))
if not self.dryrun:
self.comment_api.delete(comment['id'])
elif only_replace:
self.logger.debug('no previous comment to replace on {}'.format(debug_key))
return
self.logger.debug('adding comment to {}: {}'.format(debug_key, message))
if not self.dryrun:
self.comment_api.add_comment(comment=message, **kwargs)
self.comment_handler_remove()
def _check_matching_srcmd5(self, project, package, rev, history_limit = 5):
"""check if factory sources contain the package and revision. check head and history"""
self.logger.debug("checking %s in %s"%(package, project))
try:
osc.core.show_package_meta(self.apiurl, project, package)
except (HTTPError, URLError):
self.logger.debug("new package")
return None
si = self.get_sourceinfo(project, package)
if rev == si.verifymd5:
self.logger.debug("srcmd5 matches")
return True
if history_limit:
self.logger.debug("%s not the latest version, checking history", rev)
u = osc.core.makeurl(self.apiurl, [ 'source', project, package, '_history' ], { 'limit': history_limit })
try:
r = osc.core.http_GET(u)
except HTTPError as e:
self.logger.debug("package has no history!?")
return None
root = ET.parse(r).getroot()
# we need this complicated construct as obs doesn't honor
# the 'limit' parameter use above for obs interconnect:
# https://github.com/openSUSE/open-build-service/issues/2545
for revision, i in zip(reversed(root.findall('revision')), count()):
node = revision.find('srcmd5')
if node is None:
continue
self.logger.debug("checking %s"%node.text)
if node.text == rev:
self.logger.debug("got it, rev %s"%revision.get('rev'))
return True
if i == history_limit:
break
self.logger.debug("srcmd5 not found in history either")
return False
class TestReviewBotComment(OBSLocal.TestCase):
def setUp(self):
super(TestReviewBotComment, self).setUp()
self.api = CommentAPI(self.apiurl)
self.wf = OBSLocal.FactoryWorkflow()
self.wf.create_user('factory-auto')
self.project = self.wf.create_project(PROJECT)
# Ensure different test runs operate in unique namespace.
self.bot = '::'.join([type(self).__name__, str(random.getrandbits(8))])
self.review_bot = ReviewBot(self.apiurl,
logger=logging.getLogger(self.bot))
self.review_bot.bot_name = self.bot
self.osc_user('factory-auto')
def tearDown(self):
self.api.delete_from(project_name=PROJECT)
self.assertFalse(len(self.api.get_comments(project_name=PROJECT)))
self.osc_user('Admin')
del self.wf
def test_basic_logger(self):
self.assertFalse(self.comments_filtered(self.bot)[0])
# Initial comment.
self.review_bot.comment_handler_add()
self.review_bot.logger.info('something interesting')
self.review_bot.comment_write(project=PROJECT)
comment, _ = self.comments_filtered(self.bot)
self.assertTrue(comment['comment'].endswith('something interesting'))
# Second comment with extra line.
self.review_bot.comment_handler_add()
self.review_bot.logger.info('something interesting')
self.review_bot.logger.info('something extra')
self.review_bot.comment_write(project=PROJECT)
comment, _ = self.comments_filtered(self.bot)
self.assertTrue(comment['comment'].endswith('something extra'))
def test_workflow(self):
comment_count = len(self.api.get_comments(project_name=PROJECT))
self.assertFalse(self.comments_filtered(self.bot)[0])
# Initial comment.
info = {'state': 'seen', 'result': 'failed'}
info_extra = {'build': '1'}
info_merged = info.copy()
info_merged.update(info_extra)
self.review_bot.comment_write(state='seen',
result='failed',
identical=True,
info_extra=info_extra,
info_extra_identical=False,
project=PROJECT,
message=COMMENT)
comment, info_parsed = self.comments_filtered(self.bot)
self.assertTrue(comment['comment'].endswith(COMMENT))
self.assertEqual(info_parsed, info_merged)
# Only build change (expect no change).
info_extra = {'build': '2'}
self.review_bot.comment_write(state='seen',
result='failed',
identical=True,
info_extra=info_extra,
info_extra_identical=False,
project=PROJECT,
message=COMMENT)
comment, info_parsed = self.comments_filtered(self.bot)
self.assertTrue(comment['comment'].endswith(COMMENT))
self.assertEqual(info_parsed, info_merged)
# Build and comment (except comment replacement).
info_extra = {'build': '3'}
info_merged.update(info_extra)
self.review_bot.comment_write(state='seen',
result='failed',
identical=True,
info_extra=info_extra,
info_extra_identical=False,
project=PROJECT,
message=COMMENT + '3')
comment, info_parsed = self.comments_filtered(self.bot)
self.assertTrue(comment['comment'].endswith(COMMENT + '3'))
self.assertEqual(info_parsed, info_merged)
# Final build (except comment replacement).
info_extra = {'build': '4'}
info_merged.update(info_extra)
self.review_bot.comment_write(state='seen',
result='failed',
identical=True,
info_extra=info_extra,
info_extra_identical=True,
project=PROJECT,
message=COMMENT + '4')
comment, info_parsed = self.comments_filtered(self.bot)
self.assertTrue(comment['comment'].endswith(COMMENT + '4'))
self.assertEqual(info_parsed, info_merged)
# Final build (except comment replacement).
info = {'state': 'done', 'result': 'passed'}
info_extra = {'build': '5'}
info_merged = info.copy()
info_merged.update(info_extra)
self.review_bot.comment_write(state='done',
result='passed',
identical=True,
info_extra=info_extra,
info_extra_identical=True,
only_replace=True,
project=PROJECT,
message=COMMENT + '5')
comment, info_parsed = self.comments_filtered(self.bot)
self.assertTrue(comment['comment'].endswith(COMMENT + '5'))
self.assertEqual(info_parsed, info_merged)
# Should never be more than one new comment.
self.assertEqual(len(self.api.get_comments(project_name=PROJECT)),
comment_count + 1)
def test_only_replace_none(self):
self.review_bot.comment_write(only_replace=True,
project=PROJECT,
message=COMMENT)
self.assertFalse(self.comments_filtered(self.bot)[0])
def test_dryrun(self):
# dryrun = True, no comment.
self.review_bot.dryrun = True
self.review_bot.comment_write(project=PROJECT, message=COMMENT)
self.assertFalse(self.comments_filtered(self.bot)[0])
# dryrun = False, a comment.
self.review_bot.dryrun = False
self.review_bot.comment_write(project=PROJECT, message=COMMENT)
self.assertTrue(self.comments_filtered(self.bot)[0])
# dryrun = True, no replacement.
self.review_bot.dryrun = True
self.review_bot.comment_write(state='changed',
project=PROJECT,
message=COMMENT)
_, info = self.comments_filtered(self.bot)
self.assertEqual(info['state'], 'done')
# dryrun = False, replacement.
self.review_bot.dryrun = False
self.review_bot.comment_write(state='changed',
project=PROJECT,
message=COMMENT)
_, info = self.comments_filtered(self.bot)
self.assertEqual(info['state'], 'changed')
def test_bot_name_suffix(self):
suffix1 = 'suffix1'
bot_suffixed1 = '::'.join([self.bot, suffix1])
suffix2 = 'suffix2'
bot_suffixed2 = '::'.join([self.bot, suffix2])
self.review_bot.comment_write(bot_name_suffix=suffix1,
project=PROJECT,
message=COMMENT)
self.assertFalse(self.comments_filtered(self.bot)[0])
self.assertTrue(self.comments_filtered(bot_suffixed1)[0])
self.assertFalse(self.comments_filtered(bot_suffixed2)[0])
self.review_bot.comment_write(bot_name_suffix=suffix2,
project=PROJECT,
message=COMMENT)
self.assertFalse(self.comments_filtered(self.bot)[0])
self.assertTrue(self.comments_filtered(bot_suffixed1)[0])
self.assertTrue(self.comments_filtered(bot_suffixed2)[0])
self.review_bot.comment_write(bot_name_suffix=suffix1,
project=PROJECT,
message=COMMENT + '\nnew')
comment, _ = self.comments_filtered(bot_suffixed1)
self.assertTrue(comment['comment'].endswith(COMMENT + '\nnew'))
comment, _ = self.comments_filtered(bot_suffixed2)
self.assertTrue(comment['comment'].endswith(COMMENT))
def comments_filtered(self, bot):
comments = self.api.get_comments(project_name=PROJECT)
return self.api.comment_find(comments, bot)
class PkgListGen(ToolBase.ToolBase):
def __init__(self):
ToolBase.ToolBase.__init__(self)
self.logger = logging.getLogger(__name__)
self.comment = CommentAPI(self.apiurl)
self.reset()
def reset(self):
# package -> supportatus
self.packages = dict()
self.groups = dict()
self._supportstatus = None
self.input_dir = '.'
self.output_dir = '.'
self.lockjobs = dict()
self.ignore_broken = False
self.unwanted = set()
self.output = None
self.locales = set()
self.filtered_architectures = None
self.dry_run = False
self.all_architectures = None
def filter_architectures(self, architectures):
self.filtered_architectures = sorted(list(set(architectures) & set(self.all_architectures)))
def _load_supportstatus(self):
# XXX
fn = os.path.join(self.input_dir, 'supportstatus.txt')
self._supportstatus = dict()
if os.path.exists(fn):
with open(fn, 'r') as fh:
for line in fh:
# pkg, status
fields = line.rstrip().split(' ')
if len(fields) > 1:
self._supportstatus[fields[0]] = fields[1]
def supportstatus(self, package):
if self._supportstatus is None:
self._load_supportstatus()
return self._supportstatus.get(package)
def _load_group_file(self, fn):
output = None
unwanted = None
with open(fn, 'r') as fh:
self.logger.debug('reading %s', fn)
for groupname, group in yaml.safe_load(fh).items():
if groupname == 'OUTPUT':
output = group
continue
if groupname == 'UNWANTED':
unwanted = set(group)
continue
g = Group(groupname, self)
g.parse_yml(group)
return output, unwanted
def group_input_files(self):
return glob.glob(os.path.join(self.input_dir, 'group*.yml'))
def load_all_groups(self):
for fn in self.group_input_files():
o, u = self._load_group_file(fn)
if o:
if self.output is not None:
raise Exception('OUTPUT defined multiple times')
self.output = o
if u:
self.unwanted |= u
# required to generate release spec files (only)
def write_group_stubs(self):
archs = ['*'] + self.all_architectures
for name in self.groups:
group = self.groups[name]
group.solved_packages = dict()
fn = '{}.group'.format(group.name)
with open(os.path.join(self.output_dir, fn), 'w') as fh:
for arch in archs:
x = group.toxml(arch, group.ignore_broken, None)
x = ET.tostring(x, pretty_print=True, encoding='unicode')
fh.write(x)
def write_all_groups(self):
self._check_supplements()
summary = dict()
archs = ['*'] + self.all_architectures
for name in self.groups:
group = self.groups[name]
if not group.solved:
continue
summary[name] = group.summary()
fn = '{}.group'.format(group.name)
with open(os.path.join(self.output_dir, fn), 'w') as fh:
comment = group.comment
for arch in archs:
x = group.toxml(arch, group.ignore_broken, comment)
# only comment first time
comment = None
x = ET.tostring(x, pretty_print=True, encoding='unicode')
x = re.sub(r'\s*<!-- reason:', ' <!-- reason:', x)
fh.write(x)
return summary
def solve_module(self, groupname, includes, excludes, use_recommends):
g = self.groups[groupname]
importants = set()
for i in includes:
name = i
if isinstance(i, dict):
name = list(i)[0]
if i[name] != 'support':
importants.add(name)
else:
importants.add(name)
g.inherit(self.groups[name])
g.solve(use_recommends)
for e in excludes:
g.ignore(self.groups[e])
for i in importants:
group = self.groups[i]
for arch in group.packages:
if arch not in g.solved_packages:
continue
for package in group.packages[arch]:
if package[0] in g.solved_packages[arch]:
continue
if package[0] not in g.solved_packages['*']:
self.logger.error(f'Missing {package[0]} in {groupname} for {arch}')
def expand_repos(self, project, repo='standard'):
return repository_path_expand(self.apiurl, project, repo)
def _check_supplements(self):
tocheck = set()
tocheck_locales = set()
for arch in self.filtered_architectures:
pool = self.prepare_pool(arch, True)
sel = pool.Selection()
for s in pool.solvables_iter():
sel.add_raw(solv.Job.SOLVER_SOLVABLE, s.id)
for s in sel.solvables():
for dep in s.lookup_deparray(solv.SOLVABLE_SUPPLEMENTS):
for d in dep.str().split(' '):
if d.startswith('namespace:modalias') or d.startswith('namespace:filesystem'):
tocheck.add(s.name)
for locale in self.locales:
id = pool.str2id('locale({})'.format(locale))
for s in pool.whatprovides(id):
tocheck_locales.add(s.name)
all_grouped = set()
for g in self.groups.values():
if g.solved:
for arch in g.solved_packages.keys():
if g.solved_packages[arch]:
all_grouped.update(g.solved_packages[arch])
for p in tocheck - all_grouped:
self.logger.warning('package %s has supplements but is not grouped', p)
for p in tocheck_locales - all_grouped:
self.logger.warning('package %s provides supported locale but is not grouped', p)
def prepare_pool(self, arch, ignore_conflicts):
pool = solv.Pool()
# the i586 DVD is really a i686 one
if arch == 'i586':
pool.setarch('i686')
else:
pool.setarch(arch)
self.lockjobs[arch] = []
solvables = set()
for project, reponame in self.repos:
repo = pool.add_repo(project)
# check back the repo state to avoid suprises
state = repository_arch_state(self.apiurl, project, reponame, arch)
if state is None:
continue
s = f'repo-{project}-{reponame}-{arch}-{state}.solv'
if not repo.add_solv(s):
raise MismatchedRepoException('failed to add repo {}/{}/{}'.format(project, reponame, arch))
for solvable in repo.solvables_iter():
if ignore_conflicts:
solvable.unset(solv.SOLVABLE_CONFLICTS)
solvable.unset(solv.SOLVABLE_OBSOLETES)
# only take the first solvable in the repo chain
if not self.use_newest_version and solvable.name in solvables:
self.lockjobs[arch].append(pool.Job(solv.Job.SOLVER_SOLVABLE | solv.Job.SOLVER_LOCK, solvable.id))
solvables.add(solvable.name)
pool.addfileprovides()
pool.createwhatprovides()
for locale in self.locales:
pool.set_namespaceproviders(solv.NAMESPACE_LANGUAGE, pool.Dep(locale), True)
return pool
# parse file and merge all groups
def _parse_unneeded(self, filename):
filename = os.path.join(self.input_dir, filename)
if not os.path.isfile(filename):
return set()
fh = open(filename, 'r')
self.logger.debug('reading %s', filename)
result = set()
for group in yaml.safe_load(fh).values():
result.update(group)
return result
# the unsorted group is special and will contain all the rest for
# the FTP tree. We filter it with unneeded though to create a
# unsorted.yml file for release manager review
def _collect_unsorted_packages(self, modules, unsorted):
unneeded_regexps = [re.compile(r'\A' + r + r'\Z')
for r in self._parse_unneeded('unneeded.yml')]
packages = dict()
if unsorted:
unsorted.solved_packages = dict()
unsorted.solved_packages['*'] = dict()
for arch in self.filtered_architectures:
pool = self.prepare_pool(arch, False)
pool.Selection()
archpacks = [s.name for s in pool.solvables_iter()]
# copy
filtered = list(archpacks)
for r in unneeded_regexps:
filtered = [p for p in filtered if not r.match(p)]
# convert to set
filtered = set(filtered) - self.unwanted
for g in modules:
if unsorted and g == unsorted:
continue
for a in ('*', arch):
filtered -= set(g.solved_packages[a])
for package in filtered:
packages.setdefault(package, []).append(arch)
if unsorted:
archpacks = set(archpacks)
unsorted.solved_packages[arch] = dict()
for g in modules:
archpacks -= set(g.solved_packages[arch])
archpacks -= set(g.solved_packages['*'])
unsorted.solved_packages[arch] = dict()
for p in archpacks:
unsorted.solved_packages[arch][p] = None
if unsorted:
common = None
for arch in self.filtered_architectures:
if common is None:
common = set(unsorted.solved_packages[arch])
continue
common &= set(unsorted.solved_packages[arch])
for p in common:
unsorted.solved_packages['*'][p] = None
for arch in self.filtered_architectures:
del unsorted.solved_packages[arch][p]
with open(os.path.join(self.output_dir, 'unsorted.yml'), 'w') as fh:
fh.write('unsorted:\n')
for p in sorted(packages):
fh.write(' - ')
fh.write(p)
if len(packages[p]) != len(self.filtered_architectures):
fh.write(': [')
fh.write(','.join(sorted(packages[p])))
fh.write(']')
reason = self._find_reason(p, modules)
if reason:
fh.write(' # ' + reason)
fh.write(' \n')
# give a hint if the package is related to a group
def _find_reason(self, package, modules):
# go through the modules multiple times to find the "best"
for g in modules:
if package in g.recommends:
return 'recommended by ' + g.recommends[package]
for g in modules:
if package in g.suggested:
return 'suggested by ' + g.suggested[package]
for g in modules:
if package in g.develpkgs:
return 'devel package of ' + g.develpkgs[package]
return None
def update_one_repo(self, project, repo, arch, solv_file, solv_file_hash):
# Either hash changed or new, so remove any old hash files.
file_utils.unlink_list(None, glob.glob(solv_file + '::*'))
d = os.path.join(CACHEDIR, project, repo, arch)
if not os.path.exists(d):
os.makedirs(d)
self.logger.debug('updating %s', d)
# only there to parse the repos
bs_mirrorfull = os.path.join(SCRIPT_PATH, '..', 'bs_mirrorfull')
args = [bs_mirrorfull]
args.append('--nodebug')
args.append('{}/public/build/{}/{}/{}'.format(self.apiurl, project, repo, arch))
args.append(d)
with subprocess.Popen(args, stdout=subprocess.PIPE) as p:
for line in p.stdout:
self.logger.info(line.decode('utf-8').rstrip())
if p.wait() != 0:
raise Exception("Mirroring repository failed")
files = [os.path.join(d, f)
for f in os.listdir(d) if f.endswith('.rpm')]
suffix = f'.{os.getpid()}.tmp'
fh = open(solv_file + suffix, 'w')
p = subprocess.Popen(
['rpms2solv', '-m', '-', '-0'], stdin=subprocess.PIPE, stdout=fh)
p.communicate(bytes('\0'.join(files), 'utf-8'))
fh.close()
if p.wait() != 0:
raise Exception("rpm2solv failed")
os.rename(solv_file + suffix, solv_file)
# Create hash file now that solv creation is complete.
open(solv_file_hash, 'a').close()
def update_repos(self, architectures):
for project, repo in self.repos:
for arch in architectures:
# Fetch state before mirroring in-case it changes during download.
state = repository_arch_state(self.apiurl, project, repo, arch)
if state is None:
# Repo might not have this architecture
continue
repo_solv_name = 'repo-{}-{}-{}.solv'.format(project, repo, arch)
# Would be preferable to include hash in name, but cumbersome to handle without
# reworking a fair bit since the state needs to be tracked.
solv_file = os.path.join(CACHEDIR, repo_solv_name)
solv_file_hash = '{}::{}'.format(solv_file, state)
if os.path.exists(solv_file) and os.path.exists(solv_file_hash):
# Solve file exists and hash unchanged, skip updating solv.
self.logger.debug('skipping solv generation for {} due to matching state {}'.format(
'/'.join([project, repo, arch]), state))
else:
self.update_one_repo(project, repo, arch, solv_file, solv_file_hash)
shutil.copy(solv_file, f'./repo-{project}-{repo}-{arch}-{state}.solv')
def create_weakremovers(self, target, target_config, directory, output):
drops = dict()
dropped_repos = dict()
root = yaml.safe_load(open(os.path.join(directory, 'config.yml')))
for item in root:
key = list(item)[0]
# cast 15.1 to string :)
key = str(key)
oldrepos = set()
for suffix in ['xz', 'zst']:
oldrepos |= set(glob.glob(os.path.join(directory, f"{key}_*.packages.{suffix}")))
oldrepos |= set(glob.glob(os.path.join(directory, f"{key}.packages.{suffix}")))
for oldrepo in sorted(oldrepos):
pool = solv.Pool()
pool.setarch()
# we need some progress in the debug output - or gocd gets nervous
self.logger.debug('checking {}'.format(oldrepo))
oldsysrepo = file_utils.add_susetags(pool, oldrepo)
for arch in self.all_architectures:
for project, repo in self.repos:
# check back the repo state to avoid suprises
state = repository_arch_state(self.apiurl, project, repo, arch)
if state is None:
self.logger.debug(f'Skipping {project}/{repo}/{arch}')
fn = f'repo-{project}-{repo}-{arch}-{state}.solv'
r = pool.add_repo('/'.join([project, repo]))
if not r.add_solv(fn):
raise MismatchedRepoException('failed to add repo {}/{}/{}.'.format(project, repo, arch))
pool.createwhatprovides()
accepted_archs = set(self.all_architectures)
accepted_archs.add('noarch')
for s in oldsysrepo.solvables_iter():
oldarch = s.arch
if oldarch == 'i686':
oldarch = 'i586'
if oldarch not in accepted_archs:
continue
haveit = False
for s2 in pool.whatprovides(s.nameid):
if s2.repo == oldsysrepo or s.nameid != s2.nameid:
continue
newarch = s2.arch
if newarch == 'i686':
newarch = 'i586'
if oldarch != newarch and newarch != 'noarch' and oldarch != 'noarch':
continue
haveit = True
break
if haveit:
continue
# check for already obsoleted packages
nevr = pool.rel2id(s.nameid, s.evrid, solv.REL_EQ)
for s2 in pool.whatmatchesdep(solv.SOLVABLE_OBSOLETES, nevr):
if s2.repo == oldsysrepo:
continue
haveit = True
break
if haveit:
continue
if s.name not in drops:
drops[s.name] = {'repo': key, 'archs': set()}
if oldarch == 'noarch':
drops[s.name]['archs'] |= set(self.all_architectures)
else:
drops[s.name]['archs'].add(oldarch)
dropped_repos[key] = 1
del pool
for repo in sorted(dropped_repos):
repo_output = False
exclusives = dict()
for name in sorted(drops):
if drops[name]['repo'] != repo:
continue
if drops[name]['archs'] == set(self.all_architectures):
if not repo_output:
print('#', repo, file=output)
repo_output = True
print('Provides: weakremover({})'.format(name), file=output)
else:
jarch = ' '.join(sorted(drops[name]['archs']))
exclusives.setdefault(jarch, []).append(name)
for arch in sorted(exclusives):
if not repo_output:
print('#', repo, file=output)
repo_output = True
print('%ifarch {}'.format(arch), file=output)
for name in sorted(exclusives[arch]):
print('Provides: weakremover({})'.format(name), file=output)
print('%endif', file=output)
output.flush()
def read_summary_file(self, file):
ret = dict()
with open(file, 'r') as f:
for line in f:
pkg, group = line.strip().split(':')
ret.setdefault(pkg, [])
ret[pkg].append(group)
return ret
def calculcate_package_diff(self, old_file, new_file):
old_file = self.read_summary_file(old_file)
new_file = self.read_summary_file(new_file)
# remove common part
keys = list(old_file.keys())
for key in keys:
if new_file.get(key, []) == old_file[key]:
del new_file[key]
del old_file[key]
if not old_file and not new_file:
return None
removed = dict()
for pkg in old_file:
old_groups = old_file[pkg]
if new_file.get(pkg):
continue
removekey = ','.join(old_groups)
removed.setdefault(removekey, [])
removed[removekey].append(pkg)
report = ''
for rm in sorted(removed.keys()):
report += f"**Remove from {rm}**\n\n```\n"
paragraph = ', '.join(removed[rm])
report += "\n".join(textwrap.wrap(paragraph, width=90, break_long_words=False, break_on_hyphens=False))
report += "\n```\n\n"
moved = dict()
for pkg in old_file:
old_groups = old_file[pkg]
new_groups = new_file.get(pkg)
if not new_groups:
continue
movekey = ','.join(old_groups) + ' to ' + ','.join(new_groups)
moved.setdefault(movekey, [])
moved[movekey].append(pkg)
for move in sorted(moved.keys()):
report += f"**Move from {move}**\n\n```\n"
paragraph = ', '.join(moved[move])
report += "\n".join(textwrap.wrap(paragraph, width=90, break_long_words=False, break_on_hyphens=False))
report += "\n```\n\n"
added = dict()
for pkg in new_file:
if pkg in old_file:
continue
addkey = ','.join(new_file[pkg])
added.setdefault(addkey, [])
added[addkey].append(pkg)
for group in sorted(added):
report += f"**Add to {group}**\n\n```\n"
paragraph = ', '.join(added[group])
report += "\n".join(textwrap.wrap(paragraph, width=90, break_long_words=False, break_on_hyphens=False))
report += "\n```\n\n"
return report.strip()
def handle_package_diff(self, project, old_file, new_file):
comments = self.comment.get_comments(project_name=project)
comment, _ = self.comment.comment_find(comments, MARKER)
report = self.calculcate_package_diff(old_file, new_file)
if not report:
if comment:
self.comment.delete(comment['id'])
return 0
report = self.comment.add_marker(report, MARKER)
if comment:
write_comment = report != comment['comment']
else:
write_comment = True
if write_comment:
if comment:
self.comment.delete(comment['id'])
self.comment.add_comment(project_name=project, comment=report)
else:
for c in comments.values():
if c['parent'] == comment['id']:
print(c)
return 1
def solve_project(self, ignore_unresolvable=False, ignore_recommended=False, locale=None, locales_from=None):
self.load_all_groups()
if not self.output:
self.logger.error('OUTPUT not defined')
return
if ignore_unresolvable:
self.ignore_broken = True
global_use_recommends = not ignore_recommended
if locale:
self.locales |= set(locale.split(' '))
if locales_from:
with open(os.path.join(self.input_dir, locales_from), 'r') as fh:
root = ET.parse(fh).getroot()
self.locales |= set([lang.text for lang in root.findall('.//linguas/language')])
modules = []
# the yml parser makes an array out of everything, so
# we loop a bit more than what we support
for group in self.output:
groupname = list(group)[0]
settings = group[groupname]
if not settings: # e.g. unsorted
settings = {}
includes = settings.get('includes', [])
excludes = settings.get('excludes', [])
use_recommends = settings.get('recommends', global_use_recommends)
self.solve_module(groupname, includes, excludes, use_recommends)
g = self.groups[groupname]
# the default is a little double negated but Factory has ignore_broken
# as default and we only disable it for single groups (for now)
g.ignore_broken = not settings.get('require_all', not self.ignore_broken)
g.conflicts = settings.get('conflicts', [])
g.default_support_status = settings.get('default-support', 'unsupported')
modules.append(g)
# not defined for openSUSE
overlap = self.groups.get('overlap')
for module in modules:
module.check_dups(modules, overlap)
module.collect_devel_packages()
module.filter_already_selected(modules)
if overlap:
ignores = [x.name for x in overlap.ignored]
self.solve_module(overlap.name, [], ignores, use_recommends=False)
overlapped = set(overlap.solved_packages['*'])
for arch in self.filtered_architectures:
overlapped |= set(overlap.solved_packages[arch])
for module in modules:
if module.name == 'overlap' or module in overlap.ignored:
continue
for arch in ['*'] + self.filtered_architectures:
for p in overlapped:
module.solved_packages[arch].pop(p, None)
self._collect_unsorted_packages(modules, self.groups.get('unsorted'))
return self.write_all_groups()
def strip_medium_from_staging(self, path):
# staging projects don't need source and debug medium - and the glibc source
# rpm conflicts between standard and bootstrap_copy repository causing the
# product builder to fail
medium = re.compile('name="(DEBUG|SOURCE)MEDIUM"')
for name in glob.glob(os.path.join(path, '*.kiwi')):
lines = open(name).readlines()
lines = [x for x in lines if not medium.search(x)]
open(name, 'w').writelines(lines)
def build_stub(self, destination, extension):
with open(os.path.join(destination, '.'.join(['stub', extension])), 'w+') as f:
f.write('# prevent building single {} files twice\n'.format(extension))
f.write('Name: stub\n')
f.write('Version: 0.0\n')
def commit_package(self, path):
if self.dry_run:
package = Package(path)
for i in package.get_diff():
logging.info(''.join(i))
else:
# No proper API function to perform the same operation.
logging.debug(subprocess.check_output(
' '.join(['cd', path, '&&', 'osc', 'addremove']), shell=True, encoding='utf-8'))
package = Package(path)
package.commit(msg='Automatic update', skip_local_service_run=True)
def replace_product_version(self, product_file, product_version):
product_version = '<version>{}</version>'.format(product_version)
lines = open(product_file).readlines()
new_lines = []
for line in lines:
new_lines.append(line.replace('<version></version>', product_version))
open(product_file, 'w').write(''.join(new_lines))
def update_and_solve_target(self, api, target_project, target_config, main_repo,
project, scope, force, no_checkout,
only_release_packages, stop_after_solve):
self.all_architectures = target_config.get('pkglistgen-archs').split(' ')
self.use_newest_version = str2bool(target_config.get('pkglistgen-use-newest-version', 'False'))
self.repos = self.expand_repos(project, main_repo)
logging.debug('[{}] {}/{}: update and solve'.format(scope, project, main_repo))
group = target_config.get('pkglistgen-group', '000package-groups')
product = target_config.get('pkglistgen-product', '000product')
release = target_config.get('pkglistgen-release', '000release-packages')
oldrepos = target_config.get('pkglistgen-repos', '000update-repos')
url = api.makeurl(['source', project])
packages = ET.parse(http_GET(url)).getroot()
if packages.find('entry[@name="{}"]'.format(product)) is None:
if not self.dry_run:
undelete_package(api.apiurl, project, product, 'revive')
# TODO disable build.
logging.info('{} undeleted, skip dvd until next cycle'.format(product))
return
elif not force:
root = ET.fromstringlist(show_results_meta(api.apiurl, project, product,
repository=[main_repo], multibuild=True))
if len(root.xpath('result[@state="building"]')) or len(root.xpath('result[@state="dirty"]')):
logging.info('{}/{} build in progress'.format(project, product))
return
drop_list = api.item_exists(project, oldrepos)
checkout_list = [group, product, release]
if drop_list and not only_release_packages:
checkout_list.append(oldrepos)
if packages.find('entry[@name="{}"]'.format(release)) is None:
if not self.dry_run:
undelete_package(api.apiurl, project, release, 'revive')
logging.info('{} undeleted, skip dvd until next cycle'.format(release))
return
# Cache dir specific to hostname and project.
host = urlparse(api.apiurl).hostname
cache_dir = CacheManager.directory('pkglistgen', host, project)
if not no_checkout:
if os.path.exists(cache_dir):
shutil.rmtree(cache_dir)
os.makedirs(cache_dir)
group_dir = os.path.join(cache_dir, group)
product_dir = os.path.join(cache_dir, product)
release_dir = os.path.join(cache_dir, release)
oldrepos_dir = os.path.join(cache_dir, oldrepos)
self.input_dir = group_dir
self.output_dir = product_dir
for package in checkout_list:
if no_checkout:
logging.debug('Skipping checkout of {}/{}'.format(project, package))
continue
checkout_package(api.apiurl, project, package, expand_link=True,
prj_dir=cache_dir, outdir=os.path.join(cache_dir, package))
# print('RET', self.handle_package_diff(project, f"{group_dir}/summary-staging.txt", f"{product_dir}/summary-staging.txt"))
file_utils.unlink_all_except(release_dir, ['weakremovers.inc'])
if not only_release_packages:
file_utils.unlink_all_except(product_dir)
ignore_list = ['supportstatus.txt', 'summary-staging.txt', 'package-groups.changes']
ignore_list += self.group_input_files()
file_utils.copy_directory_contents(group_dir, product_dir, ignore_list)
file_utils.change_extension(product_dir, '.spec.in', '.spec')
file_utils.change_extension(product_dir, '.product.in', '.product')
logging.debug('-> do_update')
# make sure we only calculcate existant architectures
self.filter_architectures(target_archs(api.apiurl, project, main_repo))
self.update_repos(self.filtered_architectures)
if only_release_packages:
self.load_all_groups()
self.write_group_stubs()
else:
summary = self.solve_project(ignore_unresolvable=str2bool(target_config.get('pkglistgen-ignore-unresolvable')),
ignore_recommended=str2bool(
target_config.get('pkglistgen-ignore-recommended')),
locale=target_config.get('pkglistgen-locale'),
locales_from=target_config.get('pkglistgen-locales-from'))
if stop_after_solve:
return
if drop_list and not only_release_packages:
weakremovers_file = os.path.join(release_dir, 'weakremovers.inc')
try:
self.create_weakremovers(project, target_config, oldrepos_dir, output=open(weakremovers_file, 'w'))
except MismatchedRepoException:
logging.error("Failed to create weakremovers.inc due to mismatch in repos - project most likey started building again.")
return
delete_products = target_config.get('pkglistgen-delete-products', '').split(' ')
file_utils.unlink_list(product_dir, delete_products)
logging.debug('-> product service')
product_version = attribute_value_load(api.apiurl, project, 'ProductVersion')
if not product_version:
# for stagings the product version doesn't matter (I hope)
product_version = '1'
for product_file in glob.glob(os.path.join(product_dir, '*.product')):
self.replace_product_version(product_file, product_version)
logging.debug(subprocess.check_output(
[PRODUCT_SERVICE, product_file, product_dir, project], encoding='utf-8'))
for delete_kiwi in target_config.get('pkglistgen-delete-kiwis-{}'.format(scope), '').split(' '):
delete_kiwis = glob.glob(os.path.join(product_dir, delete_kiwi))
file_utils.unlink_list(product_dir, delete_kiwis)
if scope == 'staging':
self.strip_medium_from_staging(product_dir)
spec_files = glob.glob(os.path.join(product_dir, '*.spec'))
file_utils.move_list(spec_files, release_dir)
inc_files = glob.glob(os.path.join(group_dir, '*.inc'))
# filter special inc file
inc_files = filter(lambda file: file.endswith('weakremovers.inc'), inc_files)
file_utils.move_list(inc_files, release_dir)
# do not overwrite weakremovers.inc if it exists
# we will commit there afterwards if needed
if os.path.exists(os.path.join(group_dir, 'weakremovers.inc')) and \
not os.path.exists(os.path.join(release_dir, 'weakremovers.inc')):
file_utils.move_list([os.path.join(group_dir, 'weakremovers.inc')], release_dir)
file_utils.multibuild_from_glob(release_dir, '*.spec')
self.build_stub(release_dir, 'spec')
self.commit_package(release_dir)
if only_release_packages:
return
file_utils.multibuild_from_glob(product_dir, '*.kiwi')
self.build_stub(product_dir, 'kiwi')
reference_summary = os.path.join(group_dir, f'summary-{scope}.txt')
if os.path.isfile(reference_summary):
summary_file = os.path.join(product_dir, f'summary-{scope}.txt')
output = []
for group in summary:
for package in sorted(summary[group]):
output.append(f'{package}:{group}')
with open(summary_file, 'w') as f:
for line in sorted(output):
f.write(line + '\n')
self.commit_package(product_dir)
if os.path.isfile(reference_summary):
return self.handle_package_diff(project, reference_summary, summary_file)
class TestReviewBotComment(OBSLocal.OBSLocalTestCase):
def setUp(self):
super(TestReviewBotComment, self).setUp()
self.api = CommentAPI(self.apiurl)
# Ensure different test runs operate in unique namespace.
self.bot = '::'.join([type(self).__name__, str(random.getrandbits(8))])
self.review_bot = ReviewBot(self.apiurl, logger=logging.getLogger(self.bot))
self.review_bot.bot_name = self.bot
self.osc_user('factory-auto')
def tearDown(self):
self.api.delete_from(project_name=PROJECT)
self.assertFalse(len(self.api.get_comments(project_name=PROJECT)))
def test_basic_logger(self):
comment_count = len(self.api.get_comments(project_name=PROJECT))
self.assertFalse(self.comments_filtered(self.bot)[0])
# Initial comment.
self.review_bot.comment_handler_add()
self.review_bot.logger.info('something interesting')
self.review_bot.comment_write(project=PROJECT)
comment, _ = self.comments_filtered(self.bot)
self.assertTrue(comment['comment'].endswith('something interesting'))
# Second comment with extra line.
self.review_bot.comment_handler_add()
self.review_bot.logger.info('something interesting')
self.review_bot.logger.info('something extra')
self.review_bot.comment_write(project=PROJECT)
comment, _ = self.comments_filtered(self.bot)
self.assertTrue(comment['comment'].endswith('something extra'))
def test_workflow(self):
comment_count = len(self.api.get_comments(project_name=PROJECT))
self.assertFalse(self.comments_filtered(self.bot)[0])
# Initial comment.
info = {'state': 'seen', 'result': 'failed'}
info_extra = {'build': '1'}
info_merged = info.copy()
info_merged.update(info_extra)
self.review_bot.comment_write(state='seen', result='failed', identical=True,
info_extra=info_extra, info_extra_identical=False,
project=PROJECT, message=COMMENT)
comment, info_parsed = self.comments_filtered(self.bot)
self.assertTrue(comment['comment'].endswith(COMMENT))
self.assertEqual(info_parsed, info_merged)
# Only build change (expect no change).
info_extra = {'build': '2'}
self.review_bot.comment_write(state='seen', result='failed', identical=True,
info_extra=info_extra, info_extra_identical=False,
project=PROJECT, message=COMMENT)
comment, info_parsed = self.comments_filtered(self.bot)
self.assertTrue(comment['comment'].endswith(COMMENT))
self.assertEqual(info_parsed, info_merged)
# Build and comment (except comment replacement).
info_extra = {'build': '3'}
info_merged.update(info_extra)
self.review_bot.comment_write(state='seen', result='failed', identical=True,
info_extra=info_extra, info_extra_identical=False,
project=PROJECT, message=COMMENT + '3')
comment, info_parsed = self.comments_filtered(self.bot)
self.assertTrue(comment['comment'].endswith(COMMENT + '3'))
self.assertEqual(info_parsed, info_merged)
# Final build (except comment replacement).
info_extra = {'build': '4'}
info_merged.update(info_extra)
self.review_bot.comment_write(state='seen', result='failed', identical=True,
info_extra=info_extra, info_extra_identical=True,
project=PROJECT, message=COMMENT + '4')
comment, info_parsed = self.comments_filtered(self.bot)
self.assertTrue(comment['comment'].endswith(COMMENT + '4'))
self.assertEqual(info_parsed, info_merged)
# Final build (except comment replacement).
info = {'state': 'done', 'result': 'passed'}
info_extra = {'build': '5'}
info_merged = info.copy()
info_merged.update(info_extra)
self.review_bot.comment_write(state='done', result='passed', identical=True,
info_extra=info_extra, info_extra_identical=True,
only_replace=True,
project=PROJECT, message=COMMENT + '5')
comment, info_parsed = self.comments_filtered(self.bot)
self.assertTrue(comment['comment'].endswith(COMMENT + '5'))
self.assertEqual(info_parsed, info_merged)
# Should never be more than one new comment.
self.assertEqual(len(self.api.get_comments(project_name=PROJECT)), comment_count + 1)
def test_only_replace_none(self):
self.review_bot.comment_write(only_replace=True,
project=PROJECT, message=COMMENT)
self.assertFalse(self.comments_filtered(self.bot)[0])
def test_dryrun(self):
# dryrun = True, no comment.
self.review_bot.dryrun = True
self.review_bot.comment_write(project=PROJECT, message=COMMENT)
self.assertFalse(self.comments_filtered(self.bot)[0])
# dryrun = False, a comment.
self.review_bot.dryrun = False
self.review_bot.comment_write(project=PROJECT, message=COMMENT)
self.assertTrue(self.comments_filtered(self.bot)[0])
# dryrun = True, no replacement.
self.review_bot.dryrun = True
self.review_bot.comment_write(state='changed', project=PROJECT, message=COMMENT)
_, info = self.comments_filtered(self.bot)
self.assertEqual(info['state'], 'done')
# dryrun = False, replacement.
self.review_bot.dryrun = False
self.review_bot.comment_write(state='changed', project=PROJECT, message=COMMENT)
_, info = self.comments_filtered(self.bot)
self.assertEqual(info['state'], 'changed')
def test_bot_name_suffix(self):
suffix1 = 'suffix1'
bot_suffixed1 = '::'.join([self.bot, suffix1])
suffix2 = 'suffix2'
bot_suffixed2 = '::'.join([self.bot, suffix2])
self.review_bot.comment_write(bot_name_suffix=suffix1, project=PROJECT, message=COMMENT)
self.assertFalse(self.comments_filtered(self.bot)[0])
self.assertTrue(self.comments_filtered(bot_suffixed1)[0])
self.assertFalse(self.comments_filtered(bot_suffixed2)[0])
self.review_bot.comment_write(bot_name_suffix=suffix2, project=PROJECT, message=COMMENT)
self.assertFalse(self.comments_filtered(self.bot)[0])
self.assertTrue(self.comments_filtered(bot_suffixed1)[0])
self.assertTrue(self.comments_filtered(bot_suffixed2)[0])
self.review_bot.comment_write(bot_name_suffix=suffix1, project=PROJECT, message=COMMENT + '\nnew')
comment, _ = self.comments_filtered(bot_suffixed1)
self.assertTrue(comment['comment'].endswith(COMMENT + '\nnew'))
comment, _ = self.comments_filtered(bot_suffixed2)
self.assertTrue(comment['comment'].endswith(COMMENT))
def comments_filtered(self, bot):
comments = self.api.get_comments(project_name=PROJECT)
return self.api.comment_find(comments, bot)
class PkglistComments(object):
"""Handling staging comments of diffs"""
def __init__(self, apiurl):
self.apiurl = apiurl
self.comment = CommentAPI(apiurl)
def read_summary_file(self, file):
ret = dict()
with open(file, 'r') as f:
for line in f:
pkg, group = line.strip().split(':')
ret.setdefault(pkg, [])
ret[pkg].append(group)
return ret
def write_summary_file(self, file, content):
output = []
for pkg in sorted(content):
for group in sorted(content[pkg]):
output.append(f"{pkg}:{group}")
with open(file, 'w') as f:
for line in sorted(output):
f.write(line + '\n')
def calculcate_package_diff(self, old_file, new_file):
old_file = self.read_summary_file(old_file)
new_file = self.read_summary_file(new_file)
# remove common part
keys = list(old_file.keys())
for key in keys:
if new_file.get(key, []) == old_file[key]:
del new_file[key]
del old_file[key]
if not old_file and not new_file:
return None
removed = dict()
for pkg in old_file:
old_groups = old_file[pkg]
if new_file.get(pkg):
continue
removekey = ','.join(old_groups)
removed.setdefault(removekey, [])
removed[removekey].append(pkg)
report = ''
for rm in sorted(removed.keys()):
report += f"**Remove from {rm}**\n\n```\n"
paragraph = ', '.join(removed[rm])
report += "\n".join(textwrap.wrap(paragraph, width=90, break_long_words=False, break_on_hyphens=False))
report += "\n```\n\n"
moved = dict()
for pkg in old_file:
old_groups = old_file[pkg]
new_groups = new_file.get(pkg)
if not new_groups:
continue
movekey = ','.join(old_groups) + ' to ' + ','.join(new_groups)
moved.setdefault(movekey, [])
moved[movekey].append(pkg)
for move in sorted(moved.keys()):
report += f"**Move from {move}**\n\n```\n"
paragraph = ', '.join(moved[move])
report += "\n".join(textwrap.wrap(paragraph, width=90, break_long_words=False, break_on_hyphens=False))
report += "\n```\n\n"
added = dict()
for pkg in new_file:
if pkg in old_file:
continue
addkey = ','.join(new_file[pkg])
added.setdefault(addkey, [])
added[addkey].append(pkg)
for group in sorted(added):
report += f"**Add to {group}**\n\n```\n"
paragraph = ', '.join(added[group])
report += "\n".join(textwrap.wrap(paragraph, width=90, break_long_words=False, break_on_hyphens=False))
report += "\n```\n\n"
return report.strip()
def handle_package_diff(self, project, old_file, new_file):
comments = self.comment.get_comments(project_name=project)
comment, _ = self.comment.comment_find(comments, MARKER)
report = self.calculcate_package_diff(old_file, new_file)
if not report:
if comment:
self.comment.delete(comment['id'])
return 0
report = self.comment.add_marker(report, MARKER)
if comment:
write_comment = report != comment['comment']
else:
write_comment = True
if write_comment:
if comment:
self.comment.delete(comment['id'])
self.comment.add_comment(project_name=project, comment=report)
else:
for c in comments.values():
if c['parent'] == comment['id']:
ct = c['comment']
if ct.startswith('ignore ') or ct == 'ignore':
print(c)
return 0
if ct.startswith('approve ') or ct == 'approve':
print(c)
return 0
return 1
def is_approved(self, comment, comments):
if not comment:
return None
for c in comments.values():
if c['parent'] == comment['id']:
ct = c['comment']
if ct.startswith('approve ') or ct == 'approve':
return c['who']
return None
def parse_title(self, line):
m = re.match(r'\*\*Add to (.*)\*\*', line)
if m:
return {'cmd': 'add', 'to': m.group(1).split(','), 'pkgs': []}
m = re.match(r'\*\*Move from (.*) to (.*)\*\*', line)
if m:
return {'cmd': 'move', 'from': m.group(1).split(','), 'to': m.group(2).split(','), 'pkgs': []}
m = re.match(r'\*\*Remove from (.*)\*\*', line)
if m:
return {'cmd': 'remove', 'from': m.group(1).split(','), 'pkgs': []}
return None
def parse_sections(self, comment):
current_section = None
sections = []
in_quote = False
for line in comment.split('\n'):
if line.startswith('**'):
if current_section:
sections.append(current_section)
current_section = self.parse_title(line)
continue
if line.startswith("```"):
in_quote = not in_quote
continue
if in_quote:
for pkg in line.split(','):
pkg = pkg.strip()
if pkg:
current_section['pkgs'].append(pkg)
if current_section:
sections.append(current_section)
return sections
def apply_move(self, content, section):
for pkg in section['pkgs']:
pkg_content = content[pkg]
for group in section['from']:
try:
pkg_content.remove(group)
except ValueError:
logging.error(f"Can't remove {pkg} from {group}, not there. Mismatch.")
sys.exit(1)
for group in section['to']:
pkg_content.append(group)
content[pkg] = pkg_content
def apply_add(self, content, section):
for pkg in section['pkgs']:
content.setdefault(pkg, [])
content[pkg] += section['to']
def apply_remove(self, content, section):
for pkg in section['pkgs']:
pkg_content = content[pkg]
for group in section['from']:
try:
pkg_content.remove(group)
except ValueError:
logging.error(f"Can't remove {pkg} from {group}, not there. Mismatch.")
sys.exit(1)
content[pkg] = pkg_content
def apply_commands(self, filename, sections):
content = self.read_summary_file(filename)
for section in sections:
if section['cmd'] == 'move':
self.apply_move(content, section)
elif section['cmd'] == 'add':
self.apply_add(content, section)
elif section['cmd'] == 'remove':
self.apply_remove(content, section)
self.write_summary_file(filename, content)
def format_pkgs(self, pkgs):
text = ', '.join(pkgs)
return " " + "\n ".join(textwrap.wrap(text, width=68, break_long_words=False, break_on_hyphens=False)) + "\n\n"
def format_move(self, section):
gfrom = ','.join(section['from'])
gto = ','.join(section['to'])
text = f" * Move from {gfrom} to {gto}:\n"
return text + self.format_pkgs(section['pkgs'])
def format_add(self, section):
gto = ','.join(section['to'])
text = f" * Add to {gto}:\n"
return text + self.format_pkgs(section['pkgs'])
def format_remove(self, section):
gfrom = ','.join(section['from'])
text = f" * Remove from {gfrom}:\n"
return text + self.format_pkgs(section['pkgs'])
def apply_changes(self, filename, sections, approver):
text = "-------------------------------------------------------------------\n"
now = datetime.datetime.utcnow()
date = now.strftime("%a %b %d %H:%M:%S UTC %Y")
url = makeurl(self.apiurl, ['person', approver])
root = ET.parse(http_GET(url))
realname = root.find('realname').text
email = root.find('email').text
text += f"{date} - {realname} <{email}>\n\n- Approved changes to summary-staging.txt\n"
for section in sections:
if section['cmd'] == 'move':
text += self.format_move(section)
elif section['cmd'] == 'add':
text += self.format_add(section)
elif section['cmd'] == 'remove':
text += self.format_remove(section)
with open(filename + '.new', 'w') as writer:
writer.write(text)
with open(filename, 'r') as reader:
for line in reader:
writer.write(line)
os.rename(filename + '.new', filename)
def check_staging_accept(self, project, target):
comments = self.comment.get_comments(project_name=project)
comment, _ = self.comment.comment_find(comments, MARKER)
approver = self.is_approved(comment, comments)
if not approver:
return
sections = self.parse_sections(comment['comment'])
with tempfile.TemporaryDirectory() as tmpdirname:
checkout_package(self.apiurl, target, '000package-groups', expand_link=True, outdir=tmpdirname)
self.apply_commands(tmpdirname + '/summary-staging.txt', sections)
self.apply_changes(tmpdirname + '/package-groups.changes', sections, approver)
package = Package(tmpdirname)
package.commit(msg='Approved packagelist changes', skip_local_service_run=True)
class TestAccept(unittest.TestCase):
def setup_wf(self):
wf = OBSLocal.StagingWorkflow()
wf.setup_rings()
self.c_api = CommentAPI(wf.api.apiurl)
staging_b = wf.create_staging('B', freeze=True)
self.prj = staging_b.name
self.winerq = wf.create_submit_request('devel:wine', 'wine', text='Hallo World')
self.assertEqual(True, SelectCommand(wf.api, self.prj).perform(['wine']))
self.comments = self.c_api.get_comments(project_name=self.prj)
return wf
def test_accept_comments(self):
wf = self.setup_wf()
self.assertEqual(True, AcceptCommand(wf.api).accept_all(['B']))
# Comments are cleared up
accepted_comments = self.c_api.get_comments(project_name=self.prj)
self.assertEqual(len(accepted_comments), 0)
def test_accept_final_comment(self):
wf = self.setup_wf()
# snipe out cleanup to see the comments before the final countdown
wf.api.staging_deactivate = MagicMock(return_value=True)
self.assertEqual(True, AcceptCommand(wf.api).accept_all(['B']))
comments = self.c_api.get_comments(project_name=self.prj)
self.assertGreater(len(comments), len(self.comments))
# check which id was added
new_id = (set(comments.keys()) - set(self.comments.keys())).pop()
comment = comments[new_id]['comment']
self.assertEqual('Project "{}" accepted. The following packages have been submitted to openSUSE:Factory: wine.'.format(self.prj), comment)
def test_accept_new_multibuild_package(self):
wf = self.setup_wf()
staging = wf.create_staging('A', freeze=True)
project = wf.create_project('devel:gcc')
package = OBSLocal.Package(name='gcc9', project=project)
package.create_commit(filename='gcc9.spec')
package.create_commit(filename='gcc9-tests.spec')
package.create_commit('<multibuild><flavor>gcc9-tests.spec</flavor></multibuild>', filename='_multibuild')
wf.submit_package(package)
ret = SelectCommand(wf.api, staging.name).perform(['gcc9'])
ac = AcceptCommand(wf.api)
self.assertEqual(True, ac.accept_all(['A'], True))
# no stale links
self.assertEqual([], package_list(wf.apiurl, staging.name))
self.assertEqual(['gcc9', 'wine'], package_list(wf.apiurl, wf.project))
def test_accept_new_multispec_package(self):
wf = self.setup_wf()
staging = wf.create_staging('A', freeze=True)
project = wf.create_project('devel:gcc')
package = OBSLocal.Package(name='gcc9', project=project)
package.create_commit(filename='gcc9.spec')
package.create_commit(filename='gcc9-tests.spec')
wf.submit_package(package)
ret = SelectCommand(wf.api, staging.name).perform(['gcc9'])
ac = AcceptCommand(wf.api)
self.assertEqual(True, ac.accept_all(['A'], True))
# no stale links
self.assertEqual([], package_list(wf.apiurl, staging.name))
self.assertEqual(['gcc9', 'gcc9-tests', 'wine'], package_list(wf.apiurl, wf.project))
def test_accept_switch_to_multibuild_package(self):
wf = self.setup_wf()
staging = wf.create_staging('A', freeze=True)
tpackage = wf.create_package('target', 'gcc9')
tpackage.create_commit(filename='gcc9.spec')
tpackage.create_commit(filename='gcc9-tests.spec')
lpackage = wf.create_package('target', 'gcc9-tests')
lpackage.create_commit('<link package="gcc9" cicount="copy" />', filename='_link')
project = wf.create_project('devel:gcc')
package = OBSLocal.Package(name='gcc9', project=project)
package.create_commit(filename='gcc9.spec')
package.create_commit(filename='gcc9-tests.spec')
package.create_commit('<multibuild><flavor>gcc9-tests.spec</flavor></multibuild>', filename='_multibuild')
wf.submit_package(package)
ret = SelectCommand(wf.api, staging.name).perform(['gcc9'])
ac = AcceptCommand(wf.api)
self.assertEqual(True, ac.accept_all(['A'], True))
# no stale links
self.assertEqual([], package_list(wf.apiurl, staging.name))
self.assertEqual(['gcc9', 'wine'], package_list(wf.apiurl, wf.project))
class OpenQAReport(object):
def __init__(self, api):
self.api = api
self.comment = CommentAPI(api.apiurl)
def _package_url(self, package):
link = 'https://build.opensuse.org/package/live_build_log/%s/%s/%s/%s'
link = link % (package['project'],
package['package'],
package['repository'],
package['arch'])
text = '[%s](%s)' % (package['arch'], link)
return text
def _openQA_url(self, job):
test_name = job['name'].split('-')[-1]
link = '%s/tests/%s' % (self.api.copenqa, job['id'])
text = '[%s](%s)' % (test_name, link)
return text
def _openQA_module_url(self, job, module):
link = '%s/tests/%s/modules/%s/steps/1' % (
self.api.copenqa, job['id'], module['name']
)
text = '[%s](%s)' % (module['name'], link)
return text
def old_enough(self, _date):
time_delta = datetime.utcnow() - _date
safe_margin = timedelta(hours=MARGIN_HOURS)
return safe_margin <= time_delta
def get_info(self, project):
_prefix = '{}:'.format(self.api.cstaging)
if project.startswith(_prefix):
project = project.replace(_prefix, '')
query = {'format': 'json'}
url = self.api.makeurl(('project', 'staging_projects',
self.api.project, project), query=query)
info = json.load(self.api.retried_GET(url))
return info
def get_broken_package_status(self, info):
status = info['broken_packages']
subproject = info['subproject']
if subproject:
status.extend(subproject['broken_packages'])
return status
def get_openQA_status(self, info):
status = info['openqa_jobs']
subproject = info['subproject']
if subproject:
status.extend(subproject['openqa_jobs'])
return status
def is_there_openqa_comment(self, project):
"""Return True if there is a previous comment."""
signature = '<!-- openQA status -->'
comments = self.comment.get_comments(project_name=project)
comment = [c for c in comments.values() if signature in c['comment']]
return len(comment) > 0
def update_status_comment(self, project, report, force=False):
signature = '<!-- openQA status -->'
report = '%s\n%s' % (signature, str(report))
write_comment = False
comments = self.comment.get_comments(project_name=project)
comment = [c for c in comments.values() if signature in c['comment']]
if comment and len(comment) > 1:
print 'ERROR. There are more than one openQA status comment in %s' % project
# for c in comment:
# self.comment.delete(c['id'])
# write_comment = True
elif comment and comment[0]['comment'] != report and self.old_enough(comment[0]['when']):
self.comment.delete(comment[0]['id'])
write_comment = True
elif not comment:
write_comment = True
if write_comment or force:
if osc.conf.config['debug']:
print 'Updating comment'
self.comment.add_comment(project_name=project, comment=report)
def _report_broken_packages(self, info):
broken_package_status = self.get_broken_package_status(info)
# Group packages by name
groups = defaultdict(list)
for package in broken_package_status:
groups[package['package']].append(package)
failing_lines = [
'* Build failed %s (%s)' % (key, ', '.join(self._package_url(p) for p in value))
for key, value in groups.iteritems()
]
report = '\n'.join(failing_lines[:MAX_LINES])
if len(failing_lines) > MAX_LINES:
report += '* and more (%s) ...' % (len(failing_lines) - MAX_LINES)
return report
def _report_openQA(self, info):
failing_lines, green_lines = [], []
openQA_status = self.get_openQA_status(info)
for job in openQA_status:
test_name = job['name'].split('-')[-1]
fails = [
' * %s (%s)' % (test_name, self._openQA_module_url(job, module))
for module in job['modules'] if module['result'] == 'failed'
]
if fails:
failing_lines.extend(fails)
else:
green_lines.append(self._openQA_url(job))
failing_report, green_report = '', ''
if failing_lines:
failing_report = '* Failing tests:\n' + '\n'.join(failing_lines[:MAX_LINES])
if len(failing_lines) > MAX_LINES:
failing_report += '\n * and more (%s) ...' % (len(failing_lines) - MAX_LINES)
if green_lines:
green_report = '* Succeeding tests:' + ', '.join(green_lines[:MAX_LINES])
if len(green_lines) > MAX_LINES:
green_report += ', and more (%s) ...' % (len(green_lines) - MAX_LINES)
return '\n'.join((failing_report, green_report)).strip(), bool(failing_lines)
def report(self, project):
info = self.get_info(project)
# Some staging projects do not have info like
# openSUSE:Factory:Staging:Gcc49
if not info:
return
if info['overall_state'] == 'empty':
return
# The 'unacceptable' status means that the project will be
# replaced soon. Better do not disturb with noise.
if info['overall_state'] == 'unacceptable':
return
report_broken_packages = self._report_broken_packages(info)
report_openQA, some_openqa_fail = self._report_openQA(info)
if report_broken_packages or some_openqa_fail:
if report_broken_packages:
report_broken_packages = 'Broken:\n\n' + report_broken_packages
if report_openQA:
report_openQA = 'openQA:\n\n' + report_openQA
report = '\n\n'.join((report_broken_packages, report_openQA))
report = report.strip()
if report:
if osc.conf.config['debug']:
print project
print '-' * len(project)
print report
self.update_status_comment(project, report)
elif not info['overall_state'] == 'acceptable' and self.is_there_openqa_comment(project):
report = 'Congratulations! All fine now.'
if osc.conf.config['debug']:
print project
print '-' * len(project)
print report
self.update_status_comment(project, report, force=True)
class OpenQAReport(object):
def __init__(self, api):
self.api = api
self.comment = CommentAPI(api.apiurl)
def _package_url(self, package):
link = "https://build.opensuse.org/package/live_build_log/%s/%s/%s/%s"
link = link % (package["project"], package["package"], package["repository"], package["arch"])
text = "[%s](%s)" % (package["arch"], link)
return text
def _openQA_url(self, job):
test_name = job["name"].split("-")[-1]
link = "%s/tests/%s" % (self.api.copenqa, job["id"])
text = "[%s](%s)" % (test_name, link)
return text
def _openQA_module_url(self, job, module):
link = "%s/tests/%s/modules/%s/steps/1" % (self.api.copenqa, job["id"], module["name"])
text = "[%s](%s)" % (module["name"], link)
return text
def old_enough(self, _date):
time_delta = datetime.utcnow() - _date
safe_margin = timedelta(hours=MARGIN_HOURS)
return safe_margin <= time_delta
def get_info(self, project):
_prefix = "{}:".format(self.api.cstaging)
if project.startswith(_prefix):
project = project.replace(_prefix, "")
query = {"format": "json"}
url = self.api.makeurl(("project", "staging_projects", self.api.project, project), query=query)
info = json.load(self.api.retried_GET(url))
return info
def get_broken_package_status(self, info):
status = info["broken_packages"]
subproject = info["subproject"]
if subproject:
status.extend(subproject["broken_packages"])
return status
def get_openQA_status(self, info):
status = info["openqa_jobs"]
subproject = info["subproject"]
if subproject:
status.extend(subproject["openqa_jobs"])
return status
def is_there_openqa_comment(self, project):
"""Return True if there is a previous comment."""
signature = "<!-- openQA status -->"
comments = self.comment.get_comments(project_name=project)
comment = [c for c in comments.values() if signature in c["comment"]]
return len(comment) > 0
def update_status_comment(self, project, report, force=False):
signature = "<!-- openQA status -->"
report = "%s\n%s" % (signature, str(report))
write_comment = False
comments = self.comment.get_comments(project_name=project)
comment = [c for c in comments.values() if signature in c["comment"]]
if comment and len(comment) > 1:
print "ERROR. There are more than one openQA status comment in %s" % project
# for c in comment:
# self.comment.delete(c['id'])
# write_comment = True
elif comment and comment[0]["comment"] != report and self.old_enough(comment[0]["when"]):
self.comment.delete(comment[0]["id"])
write_comment = True
elif not comment:
write_comment = True
if write_comment or force:
if osc.conf.config["debug"]:
print "Updating comment"
self.comment.add_comment(project_name=project, comment=report)
def _report_broken_packages(self, info):
broken_package_status = self.get_broken_package_status(info)
# Group packages by name
groups = defaultdict(list)
for package in broken_package_status:
groups[package["package"]].append(package)
failing_lines = [
"* Build failed %s (%s)" % (key, ", ".join(self._package_url(p) for p in value))
for key, value in groups.iteritems()
]
report = "\n".join(failing_lines[:MAX_LINES])
if len(failing_lines) > MAX_LINES:
report += "* and more (%s) ..." % (len(failing_lines) - MAX_LINES)
return report
def _report_openQA(self, info):
failing_lines, green_lines = [], []
openQA_status = self.get_openQA_status(info)
for job in openQA_status:
test_name = job["name"].split("-")[-1]
fails = [
" * %s (%s)" % (test_name, self._openQA_module_url(job, module))
for module in job["modules"]
if module["result"] == "failed"
]
if fails:
failing_lines.extend(fails)
else:
green_lines.append(self._openQA_url(job))
failing_report, green_report = "", ""
if failing_lines:
failing_report = "* Failing openQA tests:\n" + "\n".join(failing_lines[:MAX_LINES])
if len(failing_lines) > MAX_LINES:
failing_report += "\n * and more (%s) ..." % (len(failing_lines) - MAX_LINES)
if green_lines:
green_report = "* Succeeding tests:" + ", ".join(green_lines[:MAX_LINES])
if len(green_lines) > MAX_LINES:
green_report += ", and more (%s) ..." % (len(green_lines) - MAX_LINES)
return "\n".join((failing_report, green_report)), bool(failing_lines)
def report(self, project):
info = self.get_info(project)
# Some staging projects do not have info like
# openSUSE:Factory:Staging:Gcc49
if not info:
return
if info["overall_state"] == "empty":
return
# The 'unacceptable' status means that the project will be
# replaced soon. Better do not disturb with noise.
if info["overall_state"] == "unacceptable":
return
report_broken_packages = self._report_broken_packages(info)
report_openQA, some_openqa_fail = self._report_openQA(info)
if report_broken_packages or some_openqa_fail:
report = "\n\n".join((report_broken_packages, report_openQA))
report = report.strip()
if report:
if osc.conf.config["debug"]:
print project
print "-" * len(project)
print report
self.update_status_comment(project, report)
elif not info["overall_state"] == "acceptable" and self.is_there_openqa_comment(project):
report = "Congratulations! All fine now."
if osc.conf.config["debug"]:
print project
print "-" * len(project)
print report
self.update_status_comment(project, report, force=True)
class InstallChecker(object):
def __init__(self, api, config):
self.api = api
self.config = conf.config[api.project]
self.logger = logging.getLogger('InstallChecker')
self.commentapi = CommentAPI(api.apiurl)
self.arch_whitelist = self.config.get('repo_checker-arch-whitelist')
if self.arch_whitelist:
self.arch_whitelist = set(self.arch_whitelist.split(' '))
self.ring_whitelist = set(self.config.get('repo_checker-binary-whitelist-ring', '').split(' '))
self.cycle_packages = self.config.get('repo_checker-allowed-in-cycles')
self.calculate_allowed_cycles()
self.existing_problems = self.binary_list_existing_problem(api.project, api.cmain_repo)
self.ignore_duplicated = set(self.config.get('installcheck-ignore-duplicated-binaries', '').split(' '))
def check_required_by(self, fileinfo, provides, requiredby, built_binaries, comments):
if requiredby.get('name') in built_binaries:
return True
# extract >= and the like
provide = provides.get('dep')
provide = provide.split(' ')[0]
comments.append('{} provides {} required by {}'.format(fileinfo.find('name').text, provide, requiredby.get('name')))
url = api.makeurl(['build', api.project, api.cmain_repo, 'x86_64', '_repository', requiredby.get('name') + '.rpm'],
{'view': 'fileinfo_ext'})
reverse_fileinfo = ET.parse(osc.core.http_GET(url)).getroot()
for require in reverse_fileinfo.findall('requires_ext'):
# extract >= and the like here too
dep = require.get('dep').split(' ')[0]
if dep != provide:
continue
for provided_by in require.findall('providedby'):
if provided_by.get('name') in built_binaries:
continue
comments.append(' also provided by {} -> ignoring'.format(provided_by.get('name')))
return True
comments.append('Error: missing alternative provides for {}'.format(provide))
return False
def check_delete_request(self, req, to_ignore, comments):
package = req['package']
if package in to_ignore:
self.logger.info('Delete request for package {} ignored'.format(package))
return True
built_binaries = set([])
file_infos = []
for fileinfo in fileinfo_ext_all(self.api.apiurl, self.api.project, self.api.cmain_repo, 'x86_64', package):
built_binaries.add(fileinfo.find('name').text)
file_infos.append(fileinfo)
result = True
for fileinfo in file_infos:
for provides in fileinfo.findall('provides_ext'):
for requiredby in provides.findall('requiredby[@name]'):
result = result and self.check_required_by(fileinfo, provides, requiredby, built_binaries, comments)
what_depends_on = depends_on(api.apiurl, api.project, api.cmain_repo, [package], True)
# filter out dependency on package itself (happens with eg
# java bootstrapping itself with previous build)
if package in what_depends_on:
what_depends_on.remove(package)
if len(what_depends_on):
comments.append('{} is still a build requirement of:\n\n- {}'.format(
package, '\n- '.join(sorted(what_depends_on))))
return False
return result
def packages_to_ignore(self, project):
comments = self.commentapi.get_comments(project_name=project)
ignore_re = re.compile(r'^installcheck: ignore (?P<args>.*)$', re.MULTILINE)
# the last wins, for now we don't care who said it
args = []
for comment in comments.values():
match = ignore_re.search(comment['comment'].replace('\r', ''))
if not match:
continue
args = match.group('args').strip()
# allow space and comma to seperate
args = args.replace(',', ' ').split(' ')
return args
def staging(self, project, force=False):
api = self.api
repository = self.api.cmain_repo
# fetch the build ids at the beginning - mirroring takes a while
buildids = {}
try:
architectures = self.target_archs(project, repository)
except HTTPError as e:
if e.code == 404:
# adi disappear all the time, so don't worry
return False
raise e
all_done = True
for arch in architectures:
pra = '{}/{}/{}'.format(project, repository, arch)
buildid = self.buildid(project, repository, arch)
if not buildid:
self.logger.error('No build ID in {}'.format(pra))
return False
buildids[arch] = buildid
url = self.report_url(project, repository, arch, buildid)
try:
root = ET.parse(osc.core.http_GET(url)).getroot()
check = root.find('check[@name="installcheck"]/state')
if check is not None and check.text != 'pending':
self.logger.info('{} already "{}", ignoring'.format(pra, check.text))
else:
all_done = False
except HTTPError:
self.logger.info('{} has no status report'.format(pra))
all_done = False
if all_done and not force:
return True
repository_pairs = repository_path_expand(api.apiurl, project, repository)
staging_pair = [project, repository]
result = True
status = api.project_status(project)
if not status:
self.logger.error('no project status for {}'.format(project))
return False
result_comment = []
to_ignore = self.packages_to_ignore(project)
meta = api.load_prj_pseudometa(status['description'])
for req in meta['requests']:
if req['type'] == 'delete':
result = result and self.check_delete_request(req, to_ignore, result_comment)
for arch in architectures:
# hit the first repository in the target project (if existant)
target_pair = None
directories = []
for pair_project, pair_repository in repository_pairs:
# ignore repositories only inherited for config
if repository_arch_state(self.api.apiurl, pair_project, pair_repository, arch):
if not target_pair and pair_project == api.project:
target_pair = [pair_project, pair_repository]
directories.append(self.mirror(pair_project, pair_repository, arch))
if not api.is_adi_project(project):
# For "leaky" ring packages in letter stagings, where the
# repository setup does not include the target project, that are
# not intended to to have all run-time dependencies satisfied.
whitelist = self.ring_whitelist
else:
whitelist = self.existing_problems
whitelist |= set(to_ignore)
check = self.cycle_check(project, repository, arch)
if not check.success:
self.logger.warning('Cycle check failed')
result_comment.append(check.comment)
result = False
check = self.install_check(target_pair, arch, directories, None, whitelist)
if not check.success:
self.logger.warning('Install check failed')
result_comment.append(check.comment)
result = False
duplicates = duplicated_binaries_in_repo(self.api.apiurl, project, repository)
# remove white listed duplicates
for arch in list(duplicates):
for binary in self.ignore_duplicated:
duplicates[arch].pop(binary, None)
if not len(duplicates[arch]):
del duplicates[arch]
if len(duplicates):
self.logger.warning('Found duplicated binaries')
result_comment.append(yaml.dump(duplicates, default_flow_style=False))
result = False
if result:
self.report_state('success', self.gocd_url(), project, repository, buildids)
else:
result_comment.insert(0, 'Generated from {}\n'.format(self.gocd_url()))
self.report_state('failure', self.upload_failure(project, result_comment), project, repository, buildids)
self.logger.warning('Not accepting {}'.format(project))
return False
return result
def upload_failure(self, project, comment):
print(project, '\n'.join(comment))
url = self.api.makeurl(['source', 'home:repo-checker', 'reports', project])
osc.core.http_PUT(url, data='\n'.join(comment))
url = self.api.apiurl.replace('api.', 'build.')
return '{}/package/view_file/home:repo-checker/reports/{}'.format(url, project)
def report_state(self, state, report_url, project, repository, buildids):
architectures = self.target_archs(project, repository)
for arch in architectures:
self.report_pipeline(state, report_url, project, repository, arch, buildids[arch], arch == architectures[-1])
def gocd_url(self):
if not os.environ.get('GO_SERVER_URL'):
# placeholder :)
return 'http://stephan.kulow.org/'
report_url = os.environ.get('GO_SERVER_URL').replace(':8154', '')
return report_url + '/tab/build/detail/{}/{}/{}/{}/{}#tab-console'.format(os.environ.get('GO_PIPELINE_NAME'),
os.environ.get('GO_PIPELINE_COUNTER'),
os.environ.get('GO_STAGE_NAME'),
os.environ.get('GO_STAGE_COUNTER'),
os.environ.get('GO_JOB_NAME'))
def buildid(self, project, repository, architecture):
url = self.api.makeurl(['build', project, repository, architecture], {'view': 'status'})
root = ET.parse(osc.core.http_GET(url)).getroot()
buildid = root.find('buildid')
if buildid is None:
return False
return buildid.text
def report_url(self, project, repository, architecture, buildid):
return self.api.makeurl(['status_reports', 'built', project,
repository, architecture, 'reports', buildid])
def report_pipeline(self, state, report_url, project, repository, architecture, buildid, is_last):
url = self.report_url(project, repository, architecture, buildid)
name = 'installcheck'
# this is a little bit ugly, but we don't need 2 failures. So save a success for the
# other archs to mark them as visited - pending we put in both
if not is_last:
if state == 'failure':
state = 'success'
xml = self.check_xml(report_url, state, name)
try:
osc.core.http_POST(url, data=xml)
except HTTPError:
print('failed to post status to ' + url)
sys.exit(1)
def check_xml(self, url, state, name):
check = ET.Element('check')
if url:
se = ET.SubElement(check, 'url')
se.text = url
se = ET.SubElement(check, 'state')
se.text = state
se = ET.SubElement(check, 'name')
se.text = name
return ET.tostring(check)
def target_archs(self, project, repository):
archs = target_archs(self.api.apiurl, project, repository)
# Check for arch whitelist and use intersection.
if self.arch_whitelist:
archs = list(self.arch_whitelist.intersection(set(archs)))
# Trick to prioritize x86_64.
return sorted(archs, reverse=True)
@memoize(ttl=60, session=True, add_invalidate=True)
def mirror(self, project, repository, arch):
"""Call bs_mirrorfull script to mirror packages."""
directory = os.path.join(CACHEDIR, project, repository, arch)
if not os.path.exists(directory):
os.makedirs(directory)
script = os.path.join(SCRIPT_PATH, 'bs_mirrorfull')
path = '/'.join((project, repository, arch))
url = '{}/public/build/{}'.format(self.api.apiurl, path)
parts = ['LC_ALL=C', 'perl', script, '--nodebug', url, directory]
parts = [pipes.quote(part) for part in parts]
self.logger.info('mirroring {}'.format(path))
if os.system(' '.join(parts)):
raise Exception('failed to mirror {}'.format(path))
return directory
@memoize(session=True)
def binary_list_existing_problem(self, project, repository):
"""Determine which binaries are mentioned in repo_checker output."""
binaries = set()
filename = self.project_pseudometa_file_name(project, repository)
content = project_pseudometa_file_load(self.api.apiurl, project, filename)
if not content:
self.logger.warning('no project_only run from which to extract existing problems')
return binaries
sections = self.install_check_parse(content)
for section in sections:
for binary in section.binaries:
match = re.match(BINARY_REGEX, binary)
if match:
binaries.add(match.group('name'))
return binaries
def install_check(self, target_project_pair, arch, directories,
ignore=None, whitelist=[], parse=False, no_filter=False):
self.logger.info('install check: start (ignore:{}, whitelist:{}, parse:{}, no_filter:{})'.format(
bool(ignore), len(whitelist), parse, no_filter))
with tempfile.NamedTemporaryFile() as ignore_file:
# Print ignored rpms on separate lines in ignore file.
if ignore:
for item in ignore:
ignore_file.write(item + '\n')
ignore_file.flush()
# Invoke repo_checker.pl to perform an install check.
script = os.path.join(SCRIPT_PATH, 'repo_checker.pl')
parts = ['LC_ALL=C', 'perl', script, arch, ','.join(directories),
'-f', ignore_file.name, '-w', ','.join(whitelist)]
if no_filter:
parts.append('--no-filter')
parts = [pipes.quote(part) for part in parts]
p = subprocess.Popen(' '.join(parts), shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE, close_fds=True)
stdout, stderr = p.communicate()
if p.returncode:
self.logger.info('install check: failed')
if p.returncode == 126:
self.logger.warning('mirror cache reset due to corruption')
self._invalidate_all()
elif parse:
# Parse output for later consumption for posting comments.
sections = self.install_check_parse(stdout)
self.install_check_sections_group(
target_project_pair[0], target_project_pair[1], arch, sections)
# Format output as markdown comment.
parts = []
stdout = stdout.decode('utf-8').strip()
if stdout:
parts.append(stdout + '\n')
stderr = stderr.strip()
if stderr:
parts.append(stderr + '\n')
header = '### [install check & file conflicts for {}]'.format(arch)
return CheckResult(False, header + '\n\n' + ('\n' + ('-' * 80) + '\n\n').join(parts))
self.logger.info('install check: passed')
return CheckResult(True, None)
def install_check_sections_group(self, project, repository, arch, sections):
_, binary_map = package_binary_list(self.api.apiurl, project, repository, arch)
for section in sections:
# If switch to creating bugs likely makes sense to join packages to
# form grouping key and create shared bugs for conflicts.
# Added check for b in binary_map after encountering:
# https://lists.opensuse.org/opensuse-buildservice/2017-08/msg00035.html
# Under normal circumstances this should never occur.
packages = set([binary_map[b] for b in section.binaries if b in binary_map])
for package in packages:
self.package_results.setdefault(package, [])
self.package_results[package].append(section)
def install_check_parse(self, output):
section = None
text = None
# Loop over lines and parse into chunks assigned to binaries.
for line in output.splitlines(True):
if line.startswith(' '):
if section:
text += line
else:
if section:
yield InstallSection(section, text)
match = re.match(INSTALL_REGEX, line)
if match:
# Remove empty groups since regex matches different patterns.
binaries = [b for b in match.groups() if b is not None]
section = binaries
text = line
else:
section = None
if section:
yield InstallSection(section, text)
def calculate_allowed_cycles(self):
self.allowed_cycles = []
if self.cycle_packages:
for comma_list in self.cycle_packages.split(';'):
self.allowed_cycles.append(comma_list.split(','))
def cycle_check(self, project, repository, arch):
self.logger.info('cycle check: start %s/%s/%s' % (project, repository, arch))
comment = []
depinfo = builddepinfo(self.api.apiurl, project, repository, arch, order = False)
for cycle in depinfo.findall('cycle'):
for package in cycle.findall('package'):
package = package.text
allowed = False
for acycle in self.allowed_cycles:
if package in acycle:
allowed = True
break
if not allowed:
cycled = [p.text for p in cycle.findall('package')]
comment.append('Package {} appears in cycle {}'.format(package, '/'.join(cycled)))
if len(comment):
# New cycles, post comment.
self.logger.info('cycle check: failed')
return CheckResult(False, '\n'.join(comment) + '\n')
self.logger.info('cycle check: passed')
return CheckResult(True, None)
def project_pseudometa_file_name(self, project, repository):
filename = 'repo_checker'
main_repo = Config.get(self.api.apiurl, project).get('main-repo')
if not main_repo:
filename += '.' + repository
return filename
class TestCommentOBS(OBSLocalTestCase):
def setUp(self):
super(TestCommentOBS, self).setUp()
self.api = CommentAPI(self.apiurl)
# Ensure different test runs operate in unique namespace.
self.bot = '::'.join([type(self).__name__, str(random.getrandbits(8))])
def test_basic(self):
self.osc_user('staging-bot')
self.assertFalse(self.comments_filtered(self.bot)[0])
self.assertTrue(self.api.add_comment(
project_name=PROJECT, comment=self.api.add_marker(COMMENT, self.bot)))
comment, _ = self.comments_filtered(self.bot)
self.assertTrue(comment)
self.assertTrue(self.api.delete(comment['id']))
self.assertFalse(self.comments_filtered(self.bot)[0])
def test_delete_nested(self):
self.osc_user('staging-bot')
comment_marked = self.api.add_marker(COMMENT, self.bot)
# Allow for existing comments by basing assertion on delta from initial count.
comment_count = len(self.api.get_comments(project_name=PROJECT))
self.assertFalse(self.comments_filtered(self.bot)[0])
self.assertTrue(self.api.add_comment(project_name=PROJECT, comment=comment_marked))
comment, _ = self.comments_filtered(self.bot)
self.assertTrue(comment)
for i in range(0, 3):
self.assertTrue(self.api.add_comment(
project_name=PROJECT, comment=comment_marked, parent_id=comment['id']))
comments = self.api.get_comments(project_name=PROJECT)
parented_count = 0
for comment in comments.values():
if comment['parent']:
parented_count += 1
self.assertEqual(parented_count, 3)
self.assertTrue(len(comments) == comment_count + 4)
self.api.delete_from(project_name=PROJECT)
self.assertFalse(len(self.api.get_comments(project_name=PROJECT)))
def test_delete_batch(self):
users = ['factory-auto', 'repo-checker', 'staging-bot']
for user in users:
self.osc_user(user)
from osc import conf
bot = '::'.join([self.bot, user])
comment = self.api.add_marker(COMMENT, bot)
self.assertFalse(self.comments_filtered(bot)[0])
self.assertTrue(self.api.add_comment(project_name=PROJECT, comment=comment))
self.assertTrue(self.comments_filtered(bot)[0])
# Allow for existing comments by basing assertion on delta from initial count.
comment_count = len(self.api.get_comments(project_name=PROJECT))
self.assertTrue(comment_count >= len(users))
self.api.delete_from_where_user(users[0], project_name=PROJECT)
self.assertTrue(len(self.api.get_comments(project_name=PROJECT)) == comment_count - 1)
self.api.delete_from(project_name=PROJECT)
self.assertFalse(len(self.api.get_comments(project_name=PROJECT)))
def comments_filtered(self, bot):
comments = self.api.get_comments(project_name=PROJECT)
return self.api.comment_find(comments, bot)
class OpenQABot(ReviewBot.ReviewBot):
""" check ABI of library packages
"""
def __init__(self, *args, **kwargs):
ReviewBot.ReviewBot.__init__(self, *args, **kwargs)
self.force = False
self.openqa = None
self.commentapi = CommentAPI(self.apiurl)
self.update_test_builds = dict()
self.openqa_jobs = dict()
def gather_test_builds(self):
for prj, u in TARGET_REPO_SETTINGS[self.openqa.baseurl].items():
buildnr = 0
cjob = 0
for j in self.jobs_for_target(u):
# avoid going backwards in job ID
if cjob > int(j['id']):
continue
buildnr = j['settings']['BUILD']
cjob = int(j['id'])
self.update_test_builds[prj] = buildnr
jobs = self.jobs_for_target(u, build=buildnr)
self.openqa_jobs[prj] = jobs
if self.calculate_qa_status(jobs) == QA_INPROGRESS:
self.pending_target_repos.add(prj)
# reimplemention from baseclass
def check_requests(self):
if self.apiurl.endswith('.suse.de'):
self.check_suse_incidents()
# first calculate the latest build number for current jobs
self.pending_target_repos = set()
self.gather_test_builds()
started = []
# then check progress on running incidents
for req in self.requests:
jobs = self.request_get_openqa_jobs(req,
incident=True,
test_repo=True)
ret = self.calculate_qa_status(jobs)
if ret != QA_UNKNOWN:
started.append(req)
all_requests = self.requests
self.requests = started
ReviewBot.ReviewBot.check_requests(self)
self.requests = all_requests
skipped_one = False
# now make sure the jobs are for current repo
for prj, u in TARGET_REPO_SETTINGS[self.openqa.baseurl].items():
if prj in self.pending_target_repos:
skipped_one = True
continue
self.trigger_build_for_target(prj, u)
# do not schedule new incidents unless we finished
# last wave
if skipped_one:
return
ReviewBot.ReviewBot.check_requests(self)
def check_action_maintenance_release(self, req, a):
# we only look at the binaries of the patchinfo
if a.src_package != 'patchinfo':
return None
if a.tgt_project not in PROJECT_OPENQA_SETTINGS:
self.logger.warn("not handling %s" % a.tgt_project)
return None
# TODO - this needs to be moved
return None
packages = []
# patchinfo collects the binaries and is build for an
# unpredictable architecture so we need iterate over all
url = osc.core.makeurl(
self.apiurl,
('build', a.src_project, a.tgt_project.replace(':', '_')))
root = ET.parse(osc.core.http_GET(url)).getroot()
for arch in [n.attrib['name'] for n in root.findall('entry')]:
query = {'nosource': 1}
url = osc.core.makeurl(
self.apiurl,
('build', a.src_project, a.tgt_project.replace(
':', '_'), arch, a.src_package),
query=query)
root = ET.parse(osc.core.http_GET(url)).getroot()
for binary in root.findall('binary'):
m = pkgname_re.match(binary.attrib['filename'])
if m:
# can't use arch here as the patchinfo mixes all
# archs
packages.append(
Package(m.group('name'), m.group('version'),
m.group('release')))
if not packages:
raise Exception("no packages found")
update.calculate_lastest_good_updates(self.openqa, settings)
return None
# check a set of repos for their primary checksums
@staticmethod
def calculate_repo_hash(repos):
m = md5.new()
# if you want to force it, increase this number
m.update('b')
for url in repos:
url += '/repodata/repomd.xml'
root = ET.parse(osc.core.http_GET(url)).getroot()
cs = root.find(
'.//{http://linux.duke.edu/metadata/repo}data[@type="primary"]/{http://linux.duke.edu/metadata/repo}checksum'
)
m.update(cs.text)
return m.hexdigest()
def is_incident_in_testing(self, incident):
# hard coded for now as we only run this code for SUSE Maintenance workflow
project = 'SUSE:Maintenance:%s' % incident
xpath = "(state/@name='review') and (action/source/@project='%s' and action/@type='maintenance_release')" % (
project)
res = osc.core.search(self.apiurl, request=xpath)['request']
# return the one and only (or None)
return res.find('request')
def calculate_incidents(self, incidents):
"""
get incident numbers from SUSE:Maintenance:Test project
returns dict with openQA var name : string with numbers
"""
l_incidents = []
for kind, prj in incidents.items():
packages = osc.core.meta_get_packagelist(self.apiurl, prj)
incidents = []
# filter out incidents in staging
for incident in packages:
# remove patchinfo. prefix
incident = incident.replace('_', '.').split('.')[1]
req = self.is_incident_in_testing(incident)
# without release request it's in staging
if req is None:
continue
# skip kgraft patches from aggregation
req_ = osc.core.Request()
req_.read(req)
src_prjs = set([a.src_project for a in req_.actions])
if SUSEUpdate.kgraft_target(self.apiurl, src_prjs.pop()):
continue
incidents.append(incident)
l_incidents.append((kind + '_TEST_ISSUES', ','.join(incidents)))
return l_incidents
def jobs_for_target(self, data, build=None):
s = data['settings'][0]
values = {
'distri': s['DISTRI'],
'version': s['VERSION'],
'arch': s['ARCH'],
'flavor': s['FLAVOR'],
'scope': 'relevant',
'latest': '1',
}
if build:
values['build'] = build
else:
values['test'] = data['test']
return self.openqa.openqa_request('GET', 'jobs', values)['jobs']
# we don't know the current BUILD and querying all jobs is too expensive
# so we need to check for one known TEST first
# if that job doesn't contain the proper hash, we trigger a new one
# and then we know the build
def trigger_build_for_target(self, prj, data):
today = date.today().strftime("%Y%m%d")
repohash = self.calculate_repo_hash(data['repos'])
buildnr = None
j = self.jobs_for_target(data)
for job in j:
if job['settings'].get('REPOHASH', '') == repohash:
# take the last in the row
buildnr = job['settings']['BUILD']
self.update_test_builds[prj] = buildnr
# ignore old build numbers, we want a fresh run every day
# to find regressions in the tests and to get data about
# randomly failing tests
if buildnr and buildnr.startswith(today):
return
buildnr = 0
# not found, then check for the next free build nr
for job in j:
build = job['settings']['BUILD']
if build and build.startswith(today):
try:
nr = int(build.split('-')[1])
if nr > buildnr:
buildnr = nr
except BaseException:
continue
buildnr = "%s-%d" % (today, buildnr + 1)
for s in data['settings']:
# now schedule it for real
if 'incidents' in data.keys():
for x, y in self.calculate_incidents(data['incidents']):
s[x] = y
s['BUILD'] = buildnr
s['REPOHASH'] = repohash
self.logger.debug(pformat(s))
if not self.dryrun:
try:
self.openqa.openqa_request('POST',
'isos',
data=s,
retries=1)
except Exception as e:
self.logger.debug(e)
self.update_test_builds[prj] = buildnr
def check_source_submission(self, src_project, src_package, src_rev,
dst_project, dst_package):
ReviewBot.ReviewBot.check_source_submission(self, src_project,
src_package, src_rev,
dst_project, dst_package)
def request_get_openqa_jobs(self, req, incident=True, test_repo=False):
ret = None
types = set([a.type for a in req.actions])
if 'maintenance_release' in types:
src_prjs = set([a.src_project for a in req.actions])
if len(src_prjs) != 1:
raise Exception(
"can't handle maintenance_release from different incidents"
)
build = src_prjs.pop()
tgt_prjs = set([a.tgt_project for a in req.actions])
ret = []
if incident:
ret += self.openqa_jobs[build]
for prj in sorted(tgt_prjs):
repo_settings = TARGET_REPO_SETTINGS.get(
self.openqa.baseurl, {})
if test_repo and prj in repo_settings:
repo_jobs = self.openqa_jobs[prj]
ret += repo_jobs
return ret
def calculate_qa_status(self, jobs=None):
if not jobs:
return QA_UNKNOWN
j = dict()
has_failed = False
in_progress = False
for job in jobs:
if job['clone_id']:
continue
name = job['name']
if name in j and int(job['id']) < int(j[name]['id']):
continue
j[name] = job
#self.logger.debug('job %s in openQA: %s %s %s %s', job['id'], job['settings']['VERSION'], job['settings']['TEST'], job['state'], job['result'])
if job['state'] not in ('cancelled', 'done'):
in_progress = True
else:
if job['result'] != 'passed' and job['result'] != 'softfailed':
has_failed = True
if not j:
return QA_UNKNOWN
if in_progress:
return QA_INPROGRESS
if has_failed:
return QA_FAILED
return QA_PASSED
def add_comment(self, msg, state, request_id=None, result=None):
if not self.do_comments:
return
comment = "<!-- openqa state=%s%s -->\n" % (state, ' result=%s' %
result if result else '')
comment += "\n" + msg
info = self.find_obs_request_comment(request_id=request_id)
comment_id = info.get('id', None)
if state == info.get('state', 'missing'):
lines_before = len(info['comment'].split('\n'))
lines_after = len(comment.split('\n'))
if lines_before == lines_after:
self.logger.debug(
"not worth the update, previous comment %s is state %s",
comment_id, info['state'])
return
self.logger.debug("adding comment to %s, state %s result %s",
request_id, state, result)
self.logger.debug("message: %s", msg)
if not self.dryrun:
if comment_id is not None:
self.commentapi.delete(comment_id)
self.commentapi.add_comment(request_id=request_id,
comment=str(comment))
# escape markdown
@staticmethod
def emd(str):
return str.replace('_', '\_')
def get_step_url(self, testurl, modulename):
failurl = testurl + '/modules/%s/fails' % modulename
fails = requests.get(failurl).json()
failed_step = fails.get('first_failed_step', 1)
return "[%s](%s#step/%s/%d)" % (self.emd(modulename), testurl,
modulename, failed_step)
def job_test_name(self, job):
return "%s@%s" % (self.emd(
job['settings']['TEST']), self.emd(job['settings']['MACHINE']))
def summarize_one_openqa_job(self, job):
testurl = osc.core.makeurl(self.openqa.baseurl,
['tests', str(job['id'])])
if not job['result'] in ['passed', 'failed', 'softfailed']:
rstring = job['result']
if rstring == 'none':
return None
return '\n- [%s](%s) is %s' % (self.job_test_name(job), testurl,
rstring)
modstrings = []
for module in job['modules']:
if module['result'] != 'failed':
continue
modstrings.append(self.get_step_url(testurl, module['name']))
if len(modstrings):
return '\n- [%s](%s) failed in %s' % (
self.job_test_name(job), testurl, ','.join(modstrings))
elif job['result'] == 'failed': # rare case: fail without module fails
return '\n- [%s](%s) failed' % (self.job_test_name(job), testurl)
return ''
def summarize_openqa_jobs(self, jobs):
groups = dict()
for job in jobs:
gl = "%s@%s" % (self.emd(
job['group']), self.emd(job['settings']['FLAVOR']))
if gl not in groups:
groupurl = osc.core.makeurl(
self.openqa.baseurl, ['tests', 'overview'], {
'version': job['settings']['VERSION'],
'groupid': job['group_id'],
'flavor': job['settings']['FLAVOR'],
'distri': job['settings']['DISTRI'],
'build': job['settings']['BUILD'],
})
groups[gl] = {
'title': "__Group [%s](%s)__\n" % (gl, groupurl),
'passed': 0,
'unfinished': 0,
'failed': []
}
job_summary = self.summarize_one_openqa_job(job)
if job_summary is None:
groups[gl]['unfinished'] = groups[gl]['unfinished'] + 1
continue
# None vs ''
if not len(job_summary):
groups[gl]['passed'] = groups[gl]['passed'] + 1
continue
# if there is something to report, hold the request
qa_state = QA_FAILED
gmsg = groups[gl]
groups[gl]['failed'].append(job_summary)
msg = ''
for group in sorted(groups.keys()):
msg += "\n\n" + groups[group]['title']
infos = []
if groups[group]['passed']:
infos.append("%d tests passed" % groups[group]['passed'])
if len(groups[group]['failed']):
infos.append("%d tests failed" % len(groups[group]['failed']))
if groups[group]['unfinished']:
infos.append("%d unfinished tests" %
groups[group]['unfinished'])
msg += "(" + ', '.join(infos) + ")\n"
for fail in groups[group]['failed']:
msg += fail
return msg
def check_one_request(self, req):
ret = None
try:
jobs = self.request_get_openqa_jobs(req)
qa_state = self.calculate_qa_status(jobs)
self.logger.debug("request %s state %s", req.reqid, qa_state)
msg = None
if self.force or qa_state == QA_UNKNOWN:
ret = ReviewBot.ReviewBot.check_one_request(self, req)
jobs = self.request_get_openqa_jobs(req)
if self.force:
# make sure to delete previous comments if we're forcing
info = self.find_obs_request_comment(request_id=req.reqid)
if 'id' in info:
self.logger.debug("deleting old comment %s",
info['id'])
if not self.dryrun:
self.commentapi.delete(info['id'])
if not jobs:
msg = "no openQA tests defined"
self.add_comment(msg,
'done',
request_id=req.reqid,
result='accepted')
ret = True
else:
# no notification until the result is done
osc.core.change_review_state(
self.apiurl,
req.reqid,
newstate='new',
by_group=self.review_group,
by_user=self.review_user,
message='now testing in openQA')
elif qa_state == QA_FAILED or qa_state == QA_PASSED:
# don't take test repo results into the calculation of total
# this is for humans to decide which incident broke the test repo
jobs += self.request_get_openqa_jobs(req,
incident=False,
test_repo=True)
if self.calculate_qa_status(jobs) == QA_INPROGRESS:
self.logger.debug(
"incident tests for request %s are done, but need to wait for test repo",
req.reqid)
return
if qa_state == QA_PASSED:
msg = "openQA tests passed\n"
result = 'accepted'
ret = True
else:
msg = "openQA tests problematic\n"
result = 'declined'
ret = False
msg += self.summarize_openqa_jobs(jobs)
self.add_comment(msg,
'done',
result=result,
request_id=req.reqid)
elif qa_state == QA_INPROGRESS:
self.logger.debug("request %s still in progress", req.reqid)
else:
raise Exception("unknown QA state %d", qa_state)
except Exception:
import traceback
self.logger.error("unhandled exception in openQA Bot")
self.logger.error(traceback.format_exc())
ret = None
return ret
def find_obs_request_comment(self, request_id=None, project_name=None):
"""Return previous comments (should be one)."""
if self.do_comments:
comments = self.commentapi.get_comments(request_id=request_id,
project_name=project_name)
for c in comments.values():
m = comment_marker_re.match(c['comment'])
if m:
return {
'id': c['id'],
'state': m.group('state'),
'result': m.group('result'),
'comment': c['comment'],
'revision': m.group('revision')
}
return {}
def check_product(self, job, product_prefix):
pmap = API_MAP[product_prefix]
posts = []
for arch in pmap['archs']:
need = False
settings = {
'VERSION': pmap['version'],
'ARCH': arch,
'DISTRI': 'sle'
}
issues = pmap.get('issues', {})
issues['OS_TEST_ISSUES'] = product_prefix
for key, prefix in issues.items():
if prefix + arch in job['channels']:
settings[key] = str(job['id'])
need = True
if need:
u = PROJECT_OPENQA_SETTINGS[product_prefix + arch]
u.apiurl = self.apiurl
for s in u.settings(
u.maintenance_project() + ':' + str(job['id']),
product_prefix + arch, []):
if job.get('openqa_build') is None:
job['openqa_build'] = u.get_max_revision(job)
if job.get('openqa_build') is None:
return []
s['BUILD'] += '.' + str(job['openqa_build'])
s.update(settings)
posts.append(s)
return posts
def incident_openqa_jobs(self, s):
return self.openqa.openqa_request(
'GET', 'jobs', {
'distri': s['DISTRI'],
'version': s['VERSION'],
'arch': s['ARCH'],
'flavor': s['FLAVOR'],
'build': s['BUILD'],
'scope': 'relevant',
'latest': '1'
})['jobs']
def check_suse_incidents(self):
for inc in requests.get(
'https://maintenance.suse.de/api/incident/active/').json():
# if not inc in ['5219']: continue
# if not inc.startswith('52'): continue
print inc
# continue
job = requests.get('https://maintenance.suse.de/api/incident/' +
inc).json()
if job['meta']['state'] in ['final', 'gone']:
continue
# required in job: project, id, channels
self.test_job(job['base'])
def test_job(self, job):
incident_project = str(job['project'])
comment_info = self.find_obs_request_comment(
project_name=incident_project)
comment_id = comment_info.get('id', None)
comment_build = str(comment_info.get('revision', ''))
openqa_posts = []
for prod in API_MAP.keys():
openqa_posts += self.check_product(job, prod)
openqa_jobs = []
for s in openqa_posts:
jobs = self.incident_openqa_jobs(s)
# take the project comment as marker for not posting jobs
if not len(jobs) and comment_build != str(job['openqa_build']):
if self.dryrun:
print 'WOULD POST', json.dumps(s, sort_keys=True)
else:
ret = self.openqa.openqa_request('POST',
'isos',
data=s,
retries=1)
openqa_jobs += self.incident_openqa_jobs(s)
else:
print s, 'got', len(jobs)
openqa_jobs += jobs
self.openqa_jobs[incident_project] = openqa_jobs
if len(openqa_jobs) == 0:
self.logger.debug("No openqa jobs defined")
return
# print openqa_jobs
msg = self.summarize_openqa_jobs(openqa_jobs)
state = 'seen'
result = 'none'
qa_status = self.calculate_qa_status(openqa_jobs)
if qa_status == QA_PASSED:
result = 'accepted'
state = 'done'
if qa_status == QA_FAILED:
result = 'declined'
state = 'done'
comment = "<!-- openqa state=%s result=%s revision=%s -->\n" % (
state, result, job.get('openqa_build'))
comment += "\nCC @coolo\n" + msg
if comment_id and state != 'done':
self.logger.debug("%s is already commented, wait until done",
incident_project)
return
if comment_info.get('comment', '') == comment:
self.logger.debug("%s comment did not change", incident_project)
return
self.logger.debug("adding comment to %s, state %s", incident_project,
state)
#self.logger.debug("message: %s", msg)
if not self.dryrun:
if comment_id is not None:
self.commentapi.delete(comment_id)
self.commentapi.add_comment(project_name=str(incident_project),
comment=str(comment))
class Leaper(ReviewBot.ReviewBot):
def __init__(self, *args, **kwargs):
ReviewBot.ReviewBot.__init__(self, *args, **kwargs)
self.do_comments = True
self.commentapi = CommentAPI(self.apiurl)
self.maintbot = MaintenanceChecker(*args, **kwargs)
# for FactorySourceChecker
self.factory = FactorySourceChecker(*args, **kwargs)
self.needs_reviewteam = False
self.pending_factory_submission = False
self.source_in_factory = None
self.needs_release_manager = False
self.release_manager_group = 'leap-reviewers'
self.must_approve_version_updates = False
self.must_approve_maintenance_updates = False
self.comment_marker_re = re.compile(r'<!-- leaper state=(?P<state>done|seen)(?: result=(?P<result>accepted|declined))? -->')
self.comment_log = None
self.commentlogger = LogToString(self, 'comment_log')
self.logger.addFilter(self.commentlogger)
def prepare_review(self):
# update lookup information on every run
self.factory.parse_lookup('openSUSE:Leap:42.2')
self.factory.parse_lookup('openSUSE:Leap:42.2:NonFree')
self.lookup_422 = self.factory.lookup.copy()
self.factory.lookup = {}
self.factory.parse_lookup('openSUSE:Leap:42.1:Update')
self.lookup_421 = self.factory.lookup.copy()
self.factory.lookup = {}
def check_source_submission(self, src_project, src_package, src_rev, target_project, target_package):
self.logger.info("%s/%s@%s -> %s/%s"%(src_project, src_package, src_rev, target_project, target_package))
src_srcinfo = self.get_sourceinfo(src_project, src_package, src_rev)
package = target_package
if src_srcinfo is None:
# source package does not exist?
# handle here to avoid crashing on the next line
self.logger.warn("Could not get source info for %s/%s@%s" % (src_project, src_package, src_rev))
return False
origin = None
if package in self.lookup_422:
origin = self.lookup_422[package]
is_fine_if_factory = False
not_in_factory_okish = False
if origin:
self.logger.info("expected origin is '%s'", origin)
if origin.startswith('Devel;'):
(dummy, origin, dummy) = origin.split(';')
if origin != src_project:
self.logger.debug("not submitted from devel project")
return False
is_fine_if_factory = True
not_in_factory_okish = True
if self.must_approve_version_updates:
self.needs_release_manager = True
# fall through to check history and requests
elif origin.startswith('openSUSE:Factory'):
if self.must_approve_version_updates:
self.needs_release_manager = True
if origin == src_project:
self.source_in_factory = True
return True
is_fine_if_factory = True
# fall through to check history and requests
elif origin == 'FORK':
is_fine_if_factory = True
not_in_factory_okish = True
self.needs_release_manager = True
# fall through to check history and requests
elif origin.startswith('openSUSE:Leap:42.1'):
if self.must_approve_maintenance_updates:
self.needs_release_manager = True
# submitted from :Update
if src_project.startswith(origin):
self.logger.debug("submission from 42.1 ok")
return True
# submitted from elsewhere but is in :Update
else:
good = self.factory._check_project('openSUSE:Leap:42.1:Update', target_package, src_srcinfo.verifymd5)
if good:
self.logger.info("submission found in 42.1")
return good
# check release requests too
good = self.factory._check_requests('openSUSE:Leap:42.1:Update', target_package, src_srcinfo.verifymd5)
if good or good == None:
self.logger.debug("found request")
return good
# let's see where it came from before
if package in self.lookup_421:
oldorigin = self.lookup_421[package]
self.logger.debug("oldorigin {}".format(oldorigin))
# Factory. So it's ok to keep upgrading it to Factory
# TODO: whitelist packages where this is ok and block others?
if oldorigin.startswith('openSUSE:Factory'):
self.logger.info("Package was from Factory in 42.1")
# check if an attempt to switch to SLE package is made
good = self.factory._check_project('SUSE:SLE-12-SP2:GA', target_package, src_srcinfo.verifymd5)
if good:
self.logger.info("request sources come from SLE")
self.needs_release_manager = True
return good
# the release manager needs to review attempts to upgrade to Factory
is_fine_if_factory = True
self.needs_release_manager = True
elif origin.startswith('SUSE:SLE-12'):
if self.must_approve_maintenance_updates:
self.needs_release_manager = True
# submitted from :Update
if origin == src_project:
self.logger.debug("submission origin ok")
return True
elif origin.endswith(':GA') \
and src_project == origin[:-2]+'Update':
self.logger.debug("sle update submission")
return True
# submitted from higher SP
if origin.startswith('SUSE:SLE-12:'):
if src_project.startswith('SUSE:SLE-12-SP1:') \
or src_project.startswith('SUSE:SLE-12-SP2:'):
self.logger.info("submission from service pack ok")
return True
elif origin.startswith('SUSE:SLE-12-SP1:'):
if src_project.startswith('SUSE:SLE-12-SP2:'):
self.logger.info("submission from service pack ok")
return True
self.needs_release_manager = True
good = self._check_project_and_request('openSUSE:Leap:42.2:SLE-workarounds', target_package, src_srcinfo)
if good or good == None:
self.logger.info("found sources in SLE-workarounds")
return good
# the release manager needs to review attempts to upgrade to Factory
is_fine_if_factory = True
else:
self.logger.error("unhandled origin %s", origin)
return False
else: # no origin
# submission from SLE is ok
if src_project.startswith('SUSE:SLE-12'):
return True
is_fine_if_factory = True
self.needs_release_manager = True
# we came here because none of the above checks find it good, so
# let's see if the package is in Factory at least
is_in_factory = self._check_factory(target_package, src_srcinfo)
if is_in_factory:
self.source_in_factory = True
self.needs_reviewteam = False
elif is_in_factory is None:
self.pending_factory_submission = True
self.needs_reviewteam = False
else:
if src_project.startswith('SUSE:SLE-12') \
or src_project.startswith('openSUSE:Leap:42.'):
self.needs_reviewteam = False
else:
self.needs_reviewteam = True
self.source_in_factory = False
if is_fine_if_factory:
if self.source_in_factory:
return True
elif self.pending_factory_submission:
return None
elif not_in_factory_okish:
self.needs_reviewteam = True
return True
return False
def _check_factory(self, target_package, src_srcinfo):
good = self.factory._check_project('openSUSE:Factory', target_package, src_srcinfo.verifymd5)
if good:
return good
good = self.factory._check_requests('openSUSE:Factory', target_package, src_srcinfo.verifymd5)
if good or good == None:
self.logger.debug("found request to Factory")
return good
good = self.factory._check_project('openSUSE:Factory:NonFree', target_package, src_srcinfo.verifymd5)
if good:
return good
good = self.factory._check_requests('openSUSE:Factory:NonFree', target_package, src_srcinfo.verifymd5)
if good or good == None:
self.logger.debug("found request to Factory:NonFree")
return good
return False
def _check_project_and_request(self, project, target_package, src_srcinfo):
good = self.factory._check_project(project, target_package, src_srcinfo.verifymd5)
if good:
return good
good = self.factory._check_requests(project, target_package, src_srcinfo.verifymd5)
if good or good == None:
return good
return False
def check_one_request(self, req):
self.review_messages = self.DEFAULT_REVIEW_MESSAGES.copy()
self.needs_reviewteam = False
self.needs_release_manager = False
self.pending_factory_submission = False
self.source_in_factory = None
self.comment_log = []
if len(req.actions) != 1:
msg = "only one action per request please"
self.review_messages['declined'] = msg
return False
request_ok = ReviewBot.ReviewBot.check_one_request(self, req)
has_correct_maintainer = self.maintbot.check_one_request(req)
self.logger.debug("review result: %s", request_ok)
self.logger.debug("has_correct_maintainer: %s", has_correct_maintainer)
if self.pending_factory_submission:
self.logger.info("submission is waiting for a Factory request to complete")
elif self.source_in_factory:
self.logger.info("the submitted sources are in or accepted for Factory")
elif self.source_in_factory == False:
self.logger.info("the submitted sources are NOT in Factory")
if request_ok == False:
self.logger.info("NOTE: if you think the automated review was wrong here, please talk to the release team before reopening the request")
elif self.needs_release_manager:
self.logger.info("request needs review by release management")
if self.comment_log:
result = None
if request_ok is None:
state = 'seen'
elif request_ok:
state = 'done'
result = 'accepted'
else:
state = 'done'
result = 'declined'
self.add_comment(req, '\n\n'.join(self.comment_log), state)
self.comment_log = None
if self.needs_release_manager:
add_review = True
for r in req.reviews:
if r.by_group == self.release_manager_group and (r.state == 'new' or r.state == 'accepted'):
add_review = False
self.logger.debug("%s already is a reviewer", self.release_manager_group)
break
if add_review:
if self.add_review(req, by_group = self.release_manager_group) != True:
self.review_messages['declined'] += '\nadding %s failed' % self.release_manager_group
return False
if self.needs_reviewteam:
add_review = True
self.logger.info("%s needs review by opensuse-review-team"%req.reqid)
for r in req.reviews:
if r.by_group == 'opensuse-review-team':
add_review = False
self.logger.debug("opensuse-review-team already is a reviewer")
break
if add_review:
if self.add_review(req, by_group = "opensuse-review-team") != True:
self.review_messages['declined'] += '\nadding opensuse-review-team failed'
return False
return request_ok
def check_action__default(self, req, a):
# decline all other requests for fallback reviewer
self.logger.debug("auto decline request type %s"%a.type)
return False
# TODO: make generic, move to Reviewbot. Used by multiple bots
def add_comment(self, req, msg, state, result=None):
if not self.do_comments:
return
comment = "<!-- leaper state=%s%s -->\n" % (state, ' result=%s' % result if result else '')
comment += "\n" + msg
(comment_id, comment_state, comment_result, comment_text) = self.find_obs_request_comment(req, state)
if comment_id is not None and state == comment_state:
# count number of lines as aproximation to avoid spamming requests
# for slight wording changes in the code
if len(comment_text.split('\n')) == len(comment.split('\n')):
self.logger.debug("not worth the update, previous comment %s is state %s", comment_id, comment_state)
return
self.logger.debug("adding comment to %s, state %s result %s", req.reqid, state, result)
self.logger.debug("message: %s", msg)
if not self.dryrun:
if comment_id is not None:
self.commentapi.delete(comment_id)
self.commentapi.add_comment(request_id=req.reqid, comment=str(comment))
def find_obs_request_comment(self, req, state=None):
"""Return previous comments (should be one)."""
if self.do_comments:
comments = self.commentapi.get_comments(request_id=req.reqid)
for c in comments.values():
m = self.comment_marker_re.match(c['comment'])
if m and (state is None or state == m.group('state')):
return c['id'], m.group('state'), m.group('result'), c['comment']
return None, None, None, None
def check_action__default(self, req, a):
self.logger.info("unhandled request type %s"%a.type)
self.needs_release_manager = True
return True
