| #!/usr/bin/python |
| |
| import argparse |
| import json |
| import os |
| import re |
| import sys |
| |
| from typing import Dict, Set |
| from jenkins import Jenkins |
| from jira import JIRA |
| |
| import jenkins |
| |
| # Used in logging method to flip logging on and off |
| VERBOSE = False |
| |
| # Some helpers to tidy up object indexing |
| NO_PREVIOUS_BUILD = '-1' |
| NUMBER = 'number' |
| PREVIOUS_NUMBER = 'previous_number' |
| UNKNOWN = 'unknown' |
| |
| |
| def main() -> None: |
| parser = argparse.ArgumentParser(description='Parse Jenkins build output and optionally update JIRA tickets with results for a single branch') |
| parser._action_groups.pop() |
| required = parser.add_argument_group('required arguments') |
| optional = parser.add_argument_group('optional arguments') |
| |
| required.add_argument('--jenurl', type=str, help='Jenkins server url') |
| required.add_argument('--jenuser', type=str, required=True, help='JIRA server url') |
| required.add_argument('--jenpass', type=str, required=True, help='JIRA username') |
| required.add_argument('--jiraurl', type=str, required=True, help='JIRA server url') |
| required.add_argument('--jirauser', type=str, required=True, help='JIRA username') |
| required.add_argument('--jirapass', type=str, required=True, help='JIRA password') |
| required.add_argument('--branch', metavar='b', type=str, required=True, |
| help='Branch Versions to pull Jenkins results for') |
| required.add_argument('--buildnum', metavar='n', type=str, help='Build number to process for CI status') |
| |
| optional.add_argument('--verbose', action='store_true', default='False', help='Verbose logging') |
| optional.add_argument('--auto', action='store_true', default='False', help='Update Jira tickets with CI information automatically') |
| |
| args = parser.parse_args() |
| global VERBOSE |
| if args.verbose: |
| VERBOSE = True |
| |
| # first we build the path to and confirm existence of the buildnum requested |
| jenkins_url = 'https://ci-cassandra.apache.org' |
| log('Connecting to jenkins server...') |
| server = Jenkins(jenkins_url, username=args.jenuser, password=args.jenpass) |
| |
| # We store a per-branch JSON file with cached data of test number, previous number, and all failures so we don't |
| # have to query JIRA for each build's data every time we run the script |
| ci_cache = build_local_cache(server, args.branch, args.buildnum) |
| |
| log('Retrieving build. Branch: ' + args.branch + '. Build number: ' + args.buildnum) |
| build_data = retrieve_build_details(server, args.branch, args.buildnum) |
| |
| # jira_results represents the data we're going to post to the final JIRA ticket about this CI run and test histories |
| jira_results = '[CI Results]\n' |
| jira_results += build_data.string_detailed() |
| |
| # Add a space between CI meta and test details for aesthetics |
| jira_results += '\n' |
| |
| jira = JIRA('https://issues.apache.org/jira', basic_auth=(args.jirauser, args.jirapass)) |
| |
| # Putting this in a table goes a long way towards making it parseable |
| jira_results += '||Test|Failures|JIRA||\n' |
| for test_name in build_data.test_failures: |
| failures, total, jiralink = get_test_failure_details(jira, test_name, ci_cache) |
| jira_results += ('|' + test_name + '|' + str(failures) + ' of ' + str(total) + '|' + jiralink + '\n') |
| |
| # Next, we want to query JIRA for the cassandra ticket in question and see if we've given it an update yet on build status; protect against spamming |
| post_results_to_jira(jira, build_data.JIRA, args.branch, args.auto, jira_results) |
| |
| |
| class BuildData: |
| def __init__(self, server: jenkins, branch: str, build_num: str) -> None: |
| """ |
| A lot of the guts of this are painfully parsed out of the nested data structures in the Python API of a Jenkins build |
| For example, see the Python API link on the following build on trunk: https://ci-cassandra.apache.org/job/Cassandra-trunk/959/testReport/api/ |
| (note: you may need to replace 959 w/a more recent build as they fall off the history to see it) |
| :param server: jenkins server to query; expected to already be authenticated and connected |
| :param branch: str of the branch name to pull from |
| :param build_num: str of the build number to query |
| """ |
| self.branch = branch |
| self.number = build_num |
| |
| self.paths = [] |
| # TODO: Determine if depth=5 is necessary or in any way meaningful in this API Query. If so, document why. |
| build = server.get_build_info('Cassandra-' + branch, int(build_num), depth=5) |
| |
| # The data structure and nesting in here _seems_ like it's going to be brittle and bite us in the future. |
| # Should be able to access whatever the latest format of the Python API linked above is in order to correct |
| # drifts and changes in the data structures, assuming things aren't completely dropped. |
| for change_set in build['changeSets']: |
| for items in change_set['items']: |
| self.sha = items['commitId'] |
| for path in items['affectedPaths']: |
| self.paths.append(path) |
| raw_comment = items['comment'] |
| |
| # cache this so if it doesn't match a C* JIRA we can let the user know details |
| self.commit_msg = raw_comment |
| |
| # We need to catch anyone that left bound the ticket # instead of following the idiom |
| matches = re.match(r'[\S\s^]*CASSANDRA-([0-9]+)', raw_comment) |
| if matches is not None: |
| self.JIRA = matches.group(1) |
| else: |
| # We don't need to say anything here about it; we let whomever asked about this deal with the consequences |
| self.JIRA = UNKNOWN |
| |
| self.url = build['url'] |
| |
| previous_build = build['previousBuild'] |
| if previous_build is None: |
| self.previous_number = NO_PREVIOUS_BUILD |
| else: |
| self.previous_number = previous_build[NUMBER] |
| |
| self.result = build['result'] |
| |
| tests = server.get_build_test_report('Cassandra-' + branch, int(build_num), depth=5) |
| |
| self.passcount = 0 |
| self.failcount = 0 |
| self.test_failures: Set[str] = set() |
| |
| # If we had a bad build, it's possible we have no test run results and should just be done with it |
| if not tests: |
| return |
| |
| self.passcount = tests['passCount'] |
| self.failcount = tests['failCount'] |
| |
| suites = tests['suites'] |
| for suite in suites: |
| for case in suite['cases']: |
| # We treat failures and regressions the same as we're going to rely on our history cache to provide per-test failure context |
| if (case['status'] == 'FAILED') or case['status'] == 'REGRESSION': |
| self.test_failures.add(case['className'] + '.' + case['name']) |
| |
| def string_detailed(self) -> str: |
| """ |
| Builds out detailed job runs for posting on JIRA. Whitespace is lost but it looks clean enough w/things left |
| aligned excepting the affected paths as a bullet list. |
| """ |
| result = '' |
| result += 'Branch: ' + self.branch + ', build number: ' + str(self.number) + '\n' |
| |
| prefix = '' if self.branch == 'trunk' else 'Cassandra-' |
| result += ' butler url: https://butler.cassandra.apache.org/#/ci/upstream/compare/Cassandra-' + self.branch + '/' + prefix + self.branch + '\n' |
| |
| result += ' jenkins url: ' + str(self.url) + '\n' |
| result += ' JIRA: CASSANDRA-' + str(self.JIRA) + '\n' |
| result += ' commit url: https://git-wip-us.apache.org/repos/asf?p=cassandra.git;a=commit;h=' + str(self.sha) + '\n' |
| result += ' affected paths:' + '\n' |
| for path in self.paths: |
| result += '* ' + path + '\n' |
| result += '\n Build Result: ' + self.result + '\n' |
| result += ' Passing Tests: ' + str(self.passcount) + '\n' |
| result += ' Failing Tests: ' + str(self.failcount) + '\n' |
| return result |
| |
| |
| def retrieve_build_details(server: jenkins, branch: str, build_num: int) -> BuildData: |
| result = None |
| found_build = False |
| |
| log('Retrieving requested build: ' + str(build_num) + '. Branch: ' + branch + '. build_num: ' + str(build_num)) |
| result = BuildData(server, branch, str(build_num)) |
| |
| # Some commit messages aren't JIRA related (ninjas, deb release changes, etc) |
| if result.JIRA == UNKNOWN: |
| print('No related CASSANDRA-NNNNN Jira found for build: ' + str(result.number) + '. Commit Message: ' + result.commit_msg) |
| print('Exiting processing; nothing to be done for this build if we can\'t determine the JIRA ticket it\'s associated with.') |
| sys.exit(-1) |
| |
| log('Parsed JIRA number: ' + result.JIRA + ' for build: ' + str(result.number)) |
| assert result is not None |
| return result |
| |
| |
| def post_results_to_jira(jira: JIRA, ticket_number: str, branch: str, post_to_jira: bool, ci_results: str) -> None: |
| """ |
| :param jira: Connected and authenticated JIRA instance |
| :param ticket_number: as named |
| :param branch: CI branch this job was for |
| :param post_to_jira: Whether we should actively update Jira with the comment or print it to local output |
| for a manual run / debugging |
| :param ci_results: str to post to jira ticket |
| :return: |
| """ |
| log('Attempting to connect to jira and get issue: CASSANDRA-' + ticket_number) |
| issue = jira.issue('CASSANDRA-' + ticket_number) |
| log('Checking comments on ' + str(issue)) |
| comments = issue.fields.comment.comments |
| |
| # There's a little nuance here. We have two motions we could potentially need to go through |
| # 1) We don't have anything on this ticket for this branch by JenkinsBot, so we want to add |
| # 2) We already have an entry on this ticket for this branch by JenkinsBot, so we want to update |
| |
| # TODO put the correct account name here |
| my_name = 'JenkinsBot' |
| |
| # Walk the comments for any we authored with the branch name of what we're processing. If we find it, update it |
| for comment in comments: |
| if str(comment.author) == my_name: |
| # We know we wrote it; now we need to determine if this comment was for the branch we're currently |
| # processing to determine if we need to update it |
| comment_text = jira.comment('CASSANDRA-' + ticket_number, comment) |
| if 'Branch: ' + branch in comment_text.body: |
| # This is an update |
| if post_to_jira is True: |
| comment.update(body=ci_results) |
| else: |
| print('[UPDATE] comment to manually post to Jira for CASSANDRA-' + ticket_number) |
| print(ci_results) |
| return |
| |
| if post_to_jira is True: |
| print('Posting to JIRA from the bot is not yet tested and enabled.') |
| # issue.add_comment('CASSANDRA-' + ticket_number, ci_results) |
| print('[ADD] the following comment to Jira for CASSANDRA-' + ticket_number) |
| print(ci_results) |
| else: |
| print('[ADD] the following comment to Jira for CASSANDRA-' + ticket_number) |
| print(ci_results) |
| |
| |
| def build_local_cache(server: jenkins, branch: str, buildnum: str) -> Dict: |
| """ |
| For the input build back as far as we have history, we want to cache the following (k/v): |
| NUMBER: str number of this build |
| PREVIOUS_NUMBER str build number of the previous build to walk to when walking the cache |
| failures: set of test failures seen for this build (note: sets aren't serializable in JSON so we cast to list) |
| |
| We use the build number and previous number as strings since they're going to get case to that in the JSON |
| ser/deser anyway, so best not to mix. |
| :return: testnu-> |
| """ |
| if not os.path.isdir('cache'): |
| os.mkdir('cache') |
| |
| cached_data = {} |
| json_file = 'cache/' + branch |
| if os.path.exists(json_file): |
| with open(json_file, 'r', encoding='utf-8') as infile: |
| cached_data = json.load(infile) |
| for build in cached_data: |
| log('Loaded build: [' + str(build) + '] from cache') |
| |
| while buildnum != NO_PREVIOUS_BUILD: |
| log('Processing cache for build_number ' + buildnum + ' on branch [' + branch + ']') |
| if buildnum in cached_data: |
| build_data = cached_data[buildnum] |
| log(' Already found data for ' + buildnum + ' cached locally. Continuing to ' + str(build_data[PREVIOUS_NUMBER])) |
| buildnum = str(build_data[PREVIOUS_NUMBER]) |
| else: |
| print(' Did not find build_number: ' + buildnum + ' in the json cache. Populating...') |
| # Pull the data from the Jenkins server as we don't have it in our cache |
| build_data = BuildData(server, branch, buildnum) |
| |
| # The data in our JSON cache is a pretty simple subset of what we have in BuildData for a full CI report |
| newcache_data = {} |
| newcache_data[NUMBER] = build_data.number |
| newcache_data[PREVIOUS_NUMBER] = build_data.previous_number |
| # Can't serialize sets to JSON |
| newcache_data['failures'] = list(build_data.test_failures) |
| |
| log(' Got data for ' + str(newcache_data[NUMBER]) + '. Caching and setting previous build pointer to: ' + str(newcache_data[PREVIOUS_NUMBER])) |
| if 'failures' in newcache_data: |
| log(' build number: ' + str(newcache_data[NUMBER]) + ' with failure count: ' + str(len(newcache_data['failures']))) |
| |
| # JSON comes back out as a string; need to follow suit here so the cache is all the same data type |
| cached_data[str(build_data.number)] = newcache_data |
| |
| # cast to str should be redundant but it's coming out as an int. Not worth arguing with it. |
| buildnum = str(newcache_data[PREVIOUS_NUMBER]) |
| |
| log(' Hit limit of builds. Saving JSON.') |
| with open(json_file, 'w', encoding='utf-8') as outfile: |
| log('Updating the cache with recently queried results') |
| json.dump(cached_data, outfile) |
| |
| return cached_data |
| |
| |
| def get_test_failure_details(jira: JIRA, test_name: str, data: Dict) -> tuple[int, int, str]: |
| """ |
| :param data: Dict representing JSON cached data |
| :return: failures, total, test failure JIRA url if found, link to test board if not |
| """ |
| fail_count = 0 |
| total = 0 |
| |
| for build in data: |
| build_data = data[build] |
| total += 1 |
| if test_name in build_data['failures']: |
| fail_count += 1 |
| |
| # See if we have a ticket for this failure already; pull out last 2 tokens from the . delimited test FQN |
| tokens = test_name.split('.') |
| |
| # Take the class name only; we're not looking for a perfect match, just something of a jumping off point |
| class_name = tokens[-2] |
| |
| # And split out the first token if there are underscores... /sigh |
| # https://jira.atlassian.com/browse/JRASERVER-31882 |
| ctokens = class_name.split('_') |
| class_name = ctokens[0] |
| if '[' in class_name: |
| btokens = class_name.split('[') |
| class_name = btokens[1] |
| |
| # If we have a runtime configured test name with braces in it, we search for the root test class name only since JQL |
| # is not fond of braces |
| query = 'project = CASSANDRA and resolution = unresolved and summary ~ "*' + class_name + '*"' |
| log('About to query via the following JQL: ' + query) |
| try: |
| log('Running query: ' + str(query)) |
| has_jira = jira.search_issues(query) |
| log('Result: ' + str(has_jira)) |
| except Exception as e: |
| print('ERROR! Got an exception attempting to get Jira for test failure.') |
| print('Query that raised the exception: ' + query) |
| print('Exception received: ' + str(e)) |
| print('Aborting.') |
| sys.exit(-1) |
| |
| result = '' |
| # We have a few states here: |
| # 1) Empty result; didn't find anything w/this name. Point to the test board w/link |
| # 2) We have *too many* results, or > 1. Link to the JQL that queries that so someone can check it out |
| # 3) We have a single ticket who's summary matches our failure name. |
| if has_jira == []: |
| result = '[No JIRA found|https://issues.apache.org/jira/secure/RapidBoard.jspa?rapidView=496&quickFilter=2252]' |
| elif len(has_jira) > 2: |
| # Clean up some of our most common culprits that show up in Jira queries |
| query = query.replace(' ', '%20') |
| query = query.replace('=', '%3D') |
| query = query.replace('\\', '%5C') |
| result = '[Multiple JIRAs found|https://issues.apache.org/jira/issues/?jql=' + query + ']' |
| else: |
| result = '[' + str(has_jira[0]) + '?|https://issues.apache.org/jira/browse/' + str(has_jira[0]) + ']|' |
| |
| return fail_count, total, result |
| |
| |
| def log(to_log: str) -> None: |
| if VERBOSE: |
| print(to_log) |
| |
| |
| main() |
