| #!/usr/bin/env python3 |
| # -*- coding: utf-8 -*-" |
| # |
| # Copyright 2020 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| # |
| # pylint: pylint: disable=filter-builtin-not-iterating |
| |
| """Utility command for engineers to get list of unresolved fixes |
| |
| This command can be used by engineers to get a list of unresolved |
| chromium or stable fixes. Users can ask for unresolved fixes with open CLs |
| or for unresolved fixes with conflicts. |
| |
| Before running this script, make sure you have been added to the |
| chromeos-missing-patches GCP project. |
| |
| Prerequisites to execute this script locally (RUN ONCE): |
| >> ./scripts/local/local_database_setup.py |
| |
| All locally executed commands must be run in this directory's |
| virtual env (source env/bin/activate) before running any commands. |
| The associated shell script enables this environment. |
| """ |
| |
| from __future__ import print_function |
| |
| import argparse |
| import re |
| import MySQLdb # pylint: disable=import-error |
| |
| import common |
| import git_interface |
| import missing |
| import synchronize |
| import util |
| |
| |
| # extract_numerics matches numeric parts of a Linux version as separate elements |
| # For example, "v5.4" matches "5" and "4", and "v5.4.12" matches "5", "4", and "12" |
| extract_numerics = re.compile(r'(?:v)?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?\s*') |
| |
| def branch_order(branch): |
| """Calculate numeric order of tag or branch. |
| |
| A branch with higher version number will return a larger number. |
| Ignores release candidates. For example, v5.7-rc1 will return the same |
| number as v5.7-rc2. |
| |
| Returns 0 if the kernel version can not be extracted. |
| """ |
| |
| m = extract_numerics.match(branch) |
| if m: |
| major = int(m.group(1)) |
| minor1 = int(m.group(2)) |
| minor2 = int(m.group(3)) if m.group(3) else 0 |
| return major * 10000 + minor1 * 100 + minor2 |
| return 0 |
| |
| |
| # version_baseline matches the numeric part of the major Linux version as a string |
| # For example, "v5.4.15" and "v5.4-rc3" both match "5.4" |
| version_baseline = re.compile(r'(?:v)?([0-9]+\.[0-9]+(?:\.[0-9]+)?)\s*') |
| |
| def version_list(branches, start, end): |
| """Return list of stable release branches between 'start' and 'end'. |
| |
| 'branches' is the sorted list of branches to match. |
| 'start' and 'end' can be any valid kernel version or tag. |
| If 'start' is empty or invalid, start list with first supported |
| stable branch. |
| If 'end' is empty or invalid, end list with last supported stable |
| branch. |
| """ |
| |
| offset = 0 |
| |
| if start: |
| # Extract numeric part of 'start' |
| start_match = version_baseline.match(start) |
| start = start_match.group(1) if start_match else None |
| if not start: |
| start = branches[0] |
| if end: |
| end_match = version_baseline.match(end) |
| end = end_match.group(1) if end_match else None |
| if not end: |
| end = branches[-1] |
| # If we have no 'end', also match the last branch |
| offset = 1 |
| |
| min_order = branch_order(start) |
| max_order = branch_order(end) + offset |
| return list(filter(lambda x: branch_order(x) >= min_order and branch_order(x) < max_order, |
| branches)) |
| |
| |
| def mysort(elem): |
| """Function to sort branches based on version number""" |
| _, branch = elem |
| return branch_order(branch) |
| |
| |
| def report_integration_status_sha(handler, rc_handler, branch, branch_name, sha): |
| """Report integration status for given repository, branch, and sha""" |
| |
| if rc_handler: |
| # It is possible that the patch has not yet been applied but is queued |
| # in a stable release candidate. Try to find it there as well. We use |
| # this information to override the final status if appropriate. |
| # Try applying patch and get status |
| rc_status = rc_handler.cherrypick_status(sha, branch=branch) |
| else: |
| rc_status = common.Status.OPEN |
| |
| status = handler.cherrypick_status(sha, branch=branch) |
| if status == common.Status.CONFLICT: |
| disposition = ' (queued)' if rc_status == common.Status.MERGED \ |
| else ' (conflicts - backport needed)' |
| elif status == common.Status.MERGED: |
| disposition = ' (already applied)' |
| else: |
| disposition = ' (queued)' if rc_status == common.Status.MERGED else '' |
| |
| print(' %s%s' % (branch_name, disposition)) |
| |
| def report_integration_status_branch(db, metadata, handled_shas, branch, conflicts): |
| """Report integration status for list of open patches in given repository and branch""" |
| |
| if metadata.kernel_fixes_table == 'stable_fixes': |
| table = 'linux_stable' |
| handler = git_interface.commitHandler(common.Kernel.linux_stable) |
| rc_handler = git_interface.commitHandler(common.Kernel.linux_stable_rc) |
| else: |
| table = 'linux_chrome' |
| handler = git_interface.commitHandler(common.Kernel.linux_chrome) |
| rc_handler = None |
| |
| c = db.cursor() |
| |
| status = 'CONFLICT' if conflicts else 'OPEN' |
| |
| # Walk through all fixes table entries with given status |
| q = """SELECT ct.fixedby_upstream_sha, lu.description, t.upstream_sha, t.description |
| FROM {chosen_table} AS ct |
| JOIN linux_upstream AS lu |
| ON ct.fixedby_upstream_sha = lu.sha |
| JOIN {table} as t |
| ON ct.kernel_sha = t.sha |
| WHERE ct.status = %s |
| AND ct.branch = %s""".format(chosen_table=metadata.kernel_fixes_table, table=table) |
| c.execute(q, [status, branch]) |
| for fixedby_sha, fixedby_description, fixes_sha, fixes_description in c.fetchall(): |
| # If we already handled a SHA while running this command while examining |
| # another branch, we don't need to handle it again. |
| if fixedby_sha in handled_shas: |
| continue |
| handled_shas += [fixedby_sha] |
| |
| print('Upstream commit %s ("%s")' % (fixedby_sha, fixedby_description)) |
| |
| changeid, _ = missing.get_change_id(db, branch, fixedby_sha) |
| if changeid: |
| print(' CL:%s' % changeid) |
| |
| integrated = git_interface.get_integrated_tag(fixedby_sha) |
| end = integrated |
| if not integrated: |
| integrated = 'ToT' |
| print(' upstream: %s' % integrated) |
| print(' Fixes: %s ("%s")' % (fixes_sha, fixes_description)) |
| |
| q = """SELECT sha, branch |
| FROM {table} |
| WHERE upstream_sha = %s""".format(table=table) |
| c.execute(q, [fixes_sha]) |
| fix_rows = sorted(c.fetchall(), key=mysort) |
| affected_branches = [] |
| for fix_sha, fix_branch in fix_rows: |
| if fix_branch in metadata.branches: |
| affected_branches += [fix_branch] |
| branch_name = metadata.get_kernel_branch(fix_branch) |
| print(' in %s: %s' % (branch_name, fix_sha)) |
| |
| start = git_interface.get_integrated_tag(fixes_sha) |
| if start: |
| print(' upstream: %s' % git_interface.get_integrated_tag(fixes_sha)) |
| |
| affected_branches += version_list(metadata.branches, start, end) |
| affected_branches = sorted(list(set(affected_branches)), key=branch_order) |
| if affected_branches: |
| print(' Affected branches:') |
| for affected_branch in affected_branches: |
| branch_name = metadata.get_kernel_branch(affected_branch) |
| report_integration_status_sha(handler, rc_handler, affected_branch, branch_name, |
| fixedby_sha) |
| |
| # Check if this commit has been fixed as well and, if so, report it |
| subsequent_fixes = missing.get_subsequent_fixes(db, fixedby_sha) |
| # remove initial fix |
| subsequent_fixes.pop(0) |
| if subsequent_fixes: |
| subsequent_fixes = ["\'" + sha + "\'" for sha in subsequent_fixes] |
| parsed_fixes = ', '.join(subsequent_fixes) |
| # format query here since we are inserting n values |
| q = """SELECT sha, description |
| FROM linux_upstream |
| WHERE sha in ({sha}) |
| ORDER BY FIELD(sha, {sha})""".format(sha=parsed_fixes) |
| c.execute(q) |
| fixes = c.fetchall() |
| print(' Fixed by:') |
| for fix in fixes: |
| print(' %s ("%s")' % fix) |
| |
| |
| @util.cloud_sql_proxy_decorator |
| @util.preliminary_check_decorator(False) |
| def report_integration_status(branch, conflicts, is_chromium): |
| """Report list of open patches""" |
| |
| handled_shas = [] |
| |
| if is_chromium: |
| metadata = common.get_kernel_metadata(common.Kernel.linux_chrome) |
| else: |
| metadata = common.get_kernel_metadata(common.Kernel.linux_stable) |
| |
| synchronize.synchronize_repositories(True) |
| |
| db = MySQLdb.Connect(user='linux_patches_robot', host='127.0.0.1', db='linuxdb', |
| charset='utf8mb4') |
| |
| if branch: |
| report_integration_status_branch(db, metadata, handled_shas, branch, conflicts) |
| else: |
| for b in metadata.branches: |
| print('\nBranch: linux-%s.y\n' % b) |
| report_integration_status_branch(db, metadata, handled_shas, b, conflicts) |
| |
| db.close() |
| |
| |
| def report_integration_status_parse(): |
| """Parses command line args and calls the actual function with parsed parameters |
| |
| To execute: |
| ./getopen [-b branch] [-c] [-C] |
| """ |
| |
| metadata = common.get_kernel_metadata(common.Kernel.linux_stable) |
| parser = argparse.ArgumentParser(description='Local functions to retrieve data from database') |
| parser.add_argument('-b', '--branch', type=str, choices=metadata.branches, |
| help='Branch to check') |
| parser.add_argument('-C', '--chromium', action='store_true', |
| help='Look for pending chromium patches') |
| parser.add_argument('-c', '--conflicts', action='store_true', |
| help='Check for conflicting patches') |
| args = parser.parse_args() |
| |
| report_integration_status(args.branch, args.conflicts, args.chromium) |
| |
| if __name__ == '__main__': |
| report_integration_status_parse() |
