RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2024-12-22 12:30:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

CONTRIB: release-estimator: Add release estimating tool

Browse Source 
This tool monitors the HAProxy stable branches and calculates a proposed
release date for the next minor release based on the bug fixes that are in
the queue.

Print only:
    ./release-estimator.py --print

Send email:
    ./release-estimator.py --send-mail --from-email from@domain.local --to-email to@domain.local

See contrib/release-estimator/README.md for details.
This commit is contained in:
Daniel Corbett 2020-10-22 11:19:55 -04:00 committed by Willy Tarreau
parent b1faf48222
commit e2370307be
2 changed files with 497 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
contrib/release-estimator/README.md Normal file
View File

@ -0,0 +1,68 @@
# Release Estimator
This tool monitors the HAProxy stable branches and calculates a proposed
release date for the next minor release based on the bug fixes that are in
the queue.
## Requirements
- Python 3.x
- [lxml](https://lxml.de/installation.html)
## Usage
release-estimator.py [-h] [--print] [--to-email TO_EMAIL]
[--from-email FROM_EMAIL] [--send-mail]
optional arguments:
-h, --help show this help message and exit
--print Print email only
--to-email TO_EMAIL Send email to <email>
--from-email FROM_EMAIL
Send email from <email>
--send-mail Send email
## Examples
### Print only:
./release-estimator.py --print
### Send email:
./release-estimator.py --send-mail --from-email from@domain.local --to-email to@domain.local
## How it works
For each version we check the age and apply the following logic:
- Skip the release if it's:
- older than MAX_VERSION_AGE
- older than MAX_VERSION_AGE_NONLTS days and an odd numbered release
(1.9,2.1,2.3)
- For all other valid releases we will then collect the number of bug fixes
in queue for each of the defined severity levels:
- BUG
- BUILD
- MINOR
- MEDIUM
- MAJOR
- CRITICAL
We'll then begin calculating the proposed release date based on the last
release date plus the first commit date of the first bug fix for the defined
severity level.
By default the proposed release dates use the following padding:
(Can be modified in THRESHOLDS)
- BUG/BUILD/MINOR - 28 days
- MEDIUM - 30 days
- MAJOR - 14 days
- CRITICAL - 2 days
After we have a proposed release date we will assign a release urgency
to it. As we get closer to the proposed release date the urgency level changes.
By default the urgency levels and their times are:
- WARNING - proposed date is 7 days or less
- NOTICE - proposed date is 21 days or less
- INFO - proposed date is longer than the above

429
contrib/release-estimator/release-estimator.py Executable file
View File

@ -0,0 +1,429 @@
#!/usr/bin/python3
#
# Release estimator for HAProxy
#
# A tool that monitors the HAProxy stable branches and calculates a proposed
# release date for the next minor release based on the bug fixes that are in
# the queue.
#
# Copyright 2020 HAProxy Technologies, Daniel Corbett <dcorbett@haproxy.com>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version
# 3 of the License, or (at your option) any later version.
#
#
from lxml import html
import requests
import traceback
import smtplib
import math
import copy
import time
import sys
import argparse
from datetime import datetime
from datetime import timedelta
from email.mime.text import MIMEText
# Do not report on versions older than
# MAX_VERSION_AGE.
MAX_VERSION_AGE = 1095 # days
# Do not report on non-lts releases (odd releases) that
# are older than MAX_VERSION_AGE_NONLTS
MAX_VERSION_AGE_NONLTS = 547 # days
# For each severity/issue type, set thresholds
# count - indicates how many bugs for this issue type should be in the queue
# time - indicates how many days should be added to the release date
THRESHOLDS = {
'BUG' :{ 'count' : 1, 'time' : 28},
'BUILD' :{ 'count' : 1, 'time' : 28},
'MINOR' : { 'count' : 1, 'time' : 28},
'MEDIUM' : { 'count' : 1, 'time' : 30},
'MAJOR' : { 'count' : 1, 'time' : 14 },
'CRITICAL' : { 'count' : 1, 'time' : 2 }
}
# Increase the urgency of a release as estimated time (in days) gets closer.
RELEASE_URGENCY = { 'WARNING' : 7, 'NOTICE' : 21, 'INFO' : '' }
def search_set(s, f):
for t in s:
if f in t:
return True
def check_for_email(s, parser):
if "@" not in s:
parser.print_help()
sys.exit()
def main():
global MAX_VERSION_AGE
global MAX_VERSION_AGE_NONLTS
global THRESHOLDS
global RELEASE_URGENCY
SEND_MAIL=False
VERSIONS = []
issues = {}
BUGQUEUE = {}
BUGS = { "bugs" :[] }
email_message = """Hi,
This is a friendly bot that watches fixes pending for the next haproxy-stable release! One such e-mail is sent periodically once patches are waiting in the last maintenance branch, and an ideal release date is computed based on the severity of these fixes and their merge date. Responses to this mail must be sent to the mailing list.
"""
parser = argparse.ArgumentParser(description='HAProxy Stable Release Estimator')
parser.add_argument('--print', action="store_true",
help='Print email only')
parser.add_argument('--to-email', nargs=1, required=False,
help='Send email to <email>')
parser.add_argument('--from-email', nargs=1, required=False,
help='Send email from <email>')
parser.add_argument('--send-mail', action="store_true",
help='Send email')
args = parser.parse_args()
if not args.print and not args.send_mail and not args.to_email and not args.from_email:
parser.print_help()
sys.exit()
if args.send_mail and (not args.to_email or not args.from_email):
parser.print_help()
sys.exit()
if args.to_email:
check_for_email(args.to_email[0], parser)
TO_EMAIL = args.to_email[0]
if args.from_email:
check_for_email(args.from_email[0], parser)
FROM_EMAIL = args.from_email[0]
if args.send_mail:
SEND_MAIL = True
if SEND_MAIL:
try:
TO_EMAIL
FROM_EMAIL
except:
parser.print_help()
sys.exit()
#
# Let's get the list of the current stable versions
#
page = requests.get('http://www.haproxy.org/bugs/')
tree = html.fromstring(page.content)
for x in (tree.xpath('//th')):
if x.xpath('./a/text()'):
VERSIONS.append(x.xpath('./a/text()')[0])
#
# For each version let's check it's age. We'll apply the following logic:
# - Skip the release if it's:
# * older than MAX_VERSION_AGE days
# * older than MAX_VERSION_AGE_NONLTS days and an odd numbered release (1.9,2.1,2.3)
#
# For all other valid releases we will then collect the number of bug fixes
# in queue for each of the defined severity levels:
# - BUG
# - BUILD
# - MINOR
# - MEDIUM
# - MAJOR
# - CRITICAL
#
# We'll then begin calculating the proposed release date based on the last
# release date plus the first commit date of the first bug fix for the defined
# severity level.
#
# By default the proposed release dates use the following padding:
# (Can be modified in THRESHOLDS)
# - BUG/BUILD/MINOR - 28 days
# - MEDIUM - 30 days
# - MAJOR - 14 days
# - CRITICAL - 2 days
#
# After we have a proposed release date we will assign a release urgency
# to it. As we get closer to the proposed release date the urgency level changes.
# By default the urgency levels and their times are:
# - WARNING - proposed date is 7 days or less
# - NOTICE - proposed date is 21 days or less
# - INFO - proposed date is longer than the above
#
for version in VERSIONS:
BUGQUEUE[version] = { "total" : 0, "last": "" }
VERSION_THRESHOLDS = copy.deepcopy(THRESHOLDS)
print("Collecting information on %s" % (version))
page = requests.get('http://www.haproxy.org/bugs/bugs-%s.html' % (version))
tree = html.fromstring(page.content)
issues[version] = {}
issues_count = {}
release_soon = False
num_to_word = {
1 : 'one',
2 : 'two',
3 : 'three',
4 : 'four',
5 : 'five',
6 : 'six',
7 : 'seven',
8 : 'eight',
9 : 'nine',
10 : 'ten',
11 : 'eleven',
12 : 'twelve',
13 : 'thirteen',
}
# parse out the CHANGELOG link
CHANGELOG = tree.xpath('//a[contains(@href,"CHANGELOG")]/@href')[0]
last_version = tree.xpath('//td[contains(text(), "last")]/../td/a/text()')[0]
first_version = "%s.0" % (version)
# Get CHANGELOG for release
changelog_page = requests.get(CHANGELOG)
try:
for l in changelog_page.content.decode('utf-8').split('\n'):
# the below is a bit of a hack to parse out valid years in the CHANGELOG
if (last_version in l) and ('201' in l or '202' in l or '200' in l) and '/' in l:
# set the date in which this version was last released
last_release_date = l.split(' ')[0]
last_release_datetime = datetime.strptime(last_release_date.strip(), '%Y/%m/%d')
BUGQUEUE[version]['last'] = last_release_date
break
for l in changelog_page.content.decode('utf-8').split('\n'):
# the below is a bit of a hack to parse out valid years in the CHANGELOG
if (first_version in l) and ('201' in l or '202' in l or '200' in l) and '/' in l:
# set the date in which this version was first released
first_release_date = l.split(' ')[0]
first_release_datetime = datetime.strptime(first_release_date.strip(), '%Y/%m/%d')
BUGQUEUE[version]['first'] = first_release_datetime
break
except:
print(traceback.format_exc())
last_release_date = False
# get unix timestamp for today and timestamp of first release date
today_ts = datetime.today().timestamp()
first_version_ts = BUGQUEUE[version]['first'].timestamp()
# calculate the age of this version in days and years
version_age = math.ceil((today_ts-first_version_ts)/86400)
version_age_years = math.ceil(version_age/365)
# We do not want to monitor versions that are older
# than MAX_VERSION_AGE or MAX_VERSION_AGE_NONLTS
if version_age >= MAX_VERSION_AGE:
print("\t - Version: %s is older than %d days, skipping" % (version, MAX_VERSION_AGE))
continue
if version_age > MAX_VERSION_AGE_NONLTS:
if int(version.split('.')[1]) % 2 > 0:
print("\t - Version: %s is not LTS and is older than %d days, skipping" % (version, MAX_VERSION_AGE_NONLTS))
continue
# If the release is older than 1 year let's increase the time until
# a release is due. <base time threshold> * <version age years>
if version_age_years > 1:
for k in VERSION_THRESHOLDS.keys():
VERSION_THRESHOLDS[k]['time'] *= int(version_age_years)
# Let's capture the bug table which contains each bug & their severity
bug_table = tree.xpath('//th[contains(text(), "Severity")]/ancestor::table[last()]')[0]
# Loop through bug table and parse out the title of each bug
# found within the links and their merge date.
# Example is: 2020-10-19 BUG/MINOR: disable dynamic OCSP load with BoringSSL
for x in bug_table.xpath('.//a[contains(@href,"commitdiff")]'):
# Capture the bug label
# Example: BUG/MINOR: disable dynamic OCSP load with BoringSSL
issue_tmp = x.xpath('./text()')[0]
# Capture the date
# Example: 2020-10-19
date_tmp = x.xpath('../preceding-sibling::td/text()')[0]
# Split the bug into a severity
if "/" in issue_tmp:
bug_type = issue_tmp.split(':')[0].split('/')[1].strip()
else:
bug_type = issue_tmp.split(':')[0].strip()
bug_text = ":".join(issue_tmp.split(':')[1:]).strip()
if bug_type not in issues[version].keys():
issues[version][bug_type] = set()
issues[version][bug_type].add("%s|%s" % (date_tmp, bug_text))
# Loop through the issue_types (severities) (MINOR, MEDIUM, MAJOR, etc.)
# We'll check if the severity has already been accounted for
# If not, we'll set the timestamp to the timestamp of the current issue
# If so, we'll check if the current bugs timestamp is less than the
# previous one. This will help us to determine when we first saw this
# severity type as calculations are based on the first time seeing a
# severity type. We'll then set the number of issues for each severity.
for issue_type in issues[version]:
issues_count[issue_type] = {}
for k in issues[version][issue_type]:
if 'timestamp' not in issues_count[issue_type].keys():
issues_count[issue_type]['timestamp'] = int(time.mktime(datetime.strptime(k.split('|')[0], "%Y-%m-%d").timetuple()))
else:
if issues_count[issue_type]['timestamp'] > int(time.mktime(datetime.strptime(k.split('|')[0], "%Y-%m-%d").timetuple())):
issues_count[issue_type]['timestamp'] = int(time.mktime(datetime.strptime(k.split('|')[0], "%Y-%m-%d").timetuple()))
issues_count[issue_type]['count'] = len(issues[version][issue_type])
release_date = None
total_count = 0
# Let's check the count for each severity type and see if they
# are greater than our thresholds count. This can be used to
# hold off on calculating release estimates until a certain number of
# MINOR bugs have accumulated.
for issue_type in issues_count.keys():
if issues_count[issue_type]['count'] >= VERSION_THRESHOLDS[issue_type]['count']:
# If the total number of issues is greater than the threshold
# for a severity we'll attempt to set a release date.
# We'll use the timestamp from the first time an issue was
# seen and add on the number of days specified within the
# THRESHOLDS for that issue type. We'll also increment
# the total number of issues that have been fixed in this
# version across all severities/issue types.
total_count += issues_count[issue_type]['count']
issue_timestamp_delta = datetime.fromtimestamp(int(issues_count[issue_type]['timestamp'])) + timedelta(days=int(VERSION_THRESHOLDS[issue_type]['time']))
if not release_date: release_date = issue_timestamp_delta
elif release_date > issue_timestamp_delta: release_date = issue_timestamp_delta
if release_date: release_soon = True
if release_soon:
time_until_release = release_date - datetime.now()
# If a release date has been sent, let's calculate how long
# in words until that release. i.e. "less than 2 weeks"
if release_soon:
for k in sorted(RELEASE_URGENCY.keys()):
if not RELEASE_URGENCY[k]:
release_urgency_msg = k
elif time_until_release.days <= RELEASE_URGENCY[k]:
release_urgency_msg = k
rounded_week_time = math.ceil(time_until_release.days/7.0)
if abs(rounded_week_time) > 1:
week_word = 'weeks'
else:
week_word = 'week'
try:
# We now have all of the required information for building
# the email message.
# TODO: Fix alignment
email_message = """%s
Last release %s was issued on %s. There are currently %d patches in the queue cut down this way:
""" % (email_message, last_version, last_release_datetime.strftime("%Y-%m-%d"), total_count)
for issue_type in sorted(issues_count.keys()):
email_message = "%s - %d %s, first one merged on %s\n" % (email_message, issues_count[issue_type]['count'],issue_type,datetime.fromtimestamp(int(issues_count[issue_type]['timestamp'])).strftime("%Y-%m-%d"))
email_message = "%s\nThus the computed ideal release date for %s would be %s, " % (email_message, ".".join(last_version.split(".")[:-1])+"."+str(int(last_version.split(".")[-1])+1), release_date.strftime("%Y-%m-%d"))
if rounded_week_time < 0:
email_message = "%swhich was %s %s ago.\n" % (email_message, num_to_word[abs(rounded_week_time)], week_word)
elif rounded_week_time == 0:
email_message = "%swhich was within the last week.\n" % (email_message)
else:
email_message = "%swhich is in %s %s or less.\n" % (email_message, num_to_word[rounded_week_time], week_word)
except Exception as err:
print(traceback.format_exc())
sys.exit()
# Total number of bugs fixed in this version
# since last release.
BUGQUEUE[version]['total'] = total_count
email_subject = "stable-bot: Bugfixes waiting for a release "
# Add each version & their number of bugs to the subject
for k in sorted(BUGQUEUE.keys(), reverse=True):
if BUGQUEUE[k]['total'] > 0:
email_subject = "%s %s (%d)," % ( email_subject, k, BUGQUEUE[k]['total'])
email_subject = email_subject.rstrip(",")
email_message = "%s\nThe current list of patches in the queue is:\n" % (email_message)
uniq_issues = set()
# Parse out unique issues across all versions so that we can
# print them once with the list of affected versions.
for k in BUGQUEUE.keys():
for issue_type in sorted(issues[k].keys()):
for issue in issues[k][issue_type]:
uniq_issues.add("%s|%s" % (issue_type,issue.split('|')[1]))
# Loop through the unique issues and determine which versions
# are affected.
for i in uniq_issues:
affected_versions = []
for k in BUGQUEUE.keys():
try:
if search_set(issues[k][i.split('|')[0]], i.split('|')[1]):
affected_versions.append(k)
except Exception as e:
pass
if affected_versions:
affected_versions.sort()
try:
BUGS["bugs"].append({ "affected_versions" : affected_versions, "bug":i.split('|')[1], "severity":i.split('|')[0] })
except:
BUGS["bugs"] = [ { "affected_versions" : affected_versions, "bug":i.split('|')[1], "severity":i.split('|')[0] } ]
BUGS["bugs"] = sorted(BUGS["bugs"], key = lambda i: i['severity'])
# Add each issue with affected versions to email message
# Example:
# - 1.8, 2.0, 2.1, 2.2 - MINOR : stats: fix validity of the json schema
for bug in BUGS["bugs"]:
email_message = "%s - %s %s %s : %s\n" % (email_message, ", ".join(bug["affected_versions"]).ljust(14), "-".rjust(12), bug["severity"].ljust(7), bug["bug"])
email_message="%s\n-- \nThe haproxy stable-bot is freely provided by HAProxy Technologies to help improve the quality of each HAProxy release. If you have any issue with these emails or if you want to suggest some improvements, please post them on the list so that the solutions suiting the most users can be found.\n" % (email_message)
# If a message with actual issues exists let's either print it or send out
# an email.
if "first one merged on" in email_message:
if args.print:
print(email_subject)
print(email_message)
if SEND_MAIL:
print('Send email to:%s from:%s' % (TO_EMAIL, FROM_EMAIL), end="")
msg = MIMEText(email_message)
msg['to'] = TO_EMAIL
msg['from'] = FROM_EMAIL
msg['subject'] = email_subject
msg.add_header('reply-to', TO_EMAIL)
try:
server = smtplib.SMTP('127.0.0.1', timeout=10)
server.sendmail(msg['from'], [msg['to']], msg.as_string())
print(" - Email sent")
except (ConnectionRefusedError, smtplib.SMTPConnectError):
print("- Error: SMTP Connection Error")
sys.exit()
except smtplib.SMTPServerDisconnected:
print('- Error: SMTP Server Disconnect (possible timeout)')
sys.exit()
except (smtplib.SMTPRecipientsRefused, smtplib.SMTPSenderRefused):
print('- Error: Recipients or Sender Refused')
sys.exit()
except (smtplib.SMTPHeloError, smtplib.SMTPAuthenticationError):
print('- Error: SMTP rejected HELO or requires Authentication')
sys.exit()
except:
print(traceback.format_exc())
sys.exit()
if __name__ == "__main__":
main()
sys.exit()