Source code
Revision control
Copy as Markdown
Other Tools
#!/usr/bin/env python3
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
import re
import sys
from subprocess import check_output
def exit_with_failure(message):
print(f"ERROR: {message}", file=sys.stderr)
sys.exit(1)
def version_string_to_underscore(version_string):
"""Convert version string like '3.118' to '3_118'."""
return version_string.replace(".", "_")
def version_string_to_RTM_tag(version_string):
"""Convert version string like '3.118' to 'NSS_3_118_RTM'."""
parts = version_string.split(".")
return "NSS_" + "_".join(parts) + "_RTM"
def get_nspr_version(rev=None):
"""Read the NSPR version from automation/release/nspr-version.txt.
If rev is given, reads the file at that hg revision; otherwise reads the
working-directory copy.
"""
nspr_version_file = "automation/release/nspr-version.txt"
if rev is not None:
try:
content = check_output(["hg", "cat", "-r", rev, nspr_version_file]).decode()
return content.splitlines()[0].strip()
except Exception as e:
exit_with_failure(
f"Could not read {nspr_version_file} at revision {rev}: {e}"
)
try:
with open(nspr_version_file, "r") as f:
return f.readline().strip()
except FileNotFoundError:
exit_with_failure(
f"Could not find {nspr_version_file}. Are you running from the NSS root directory?"
)
def get_rtm_tag_date(rtm_tag):
"""Return the date of the RTM tag as a formatted string, or None if tag doesn't exist."""
try:
raw = (
check_output(["hg", "log", "-r", rtm_tag, "--template", "{date|shortdate}"])
.decode()
.strip()
)
from datetime import datetime
dt = datetime.strptime(raw, "%Y-%m-%d")
return dt.strftime("%-d %B %Y")
except Exception:
return None
def tag_exists(tag):
"""Return True if the given Mercurial tag resolves in the current repo."""
try:
check_output(["hg", "log", "-r", tag, "--template", "x"])
return True
except Exception:
return False
def default_branch_has_version(major, minor):
"""Return True if lib/nss/nss.h on the default branch tip has NSS_VMAJOR/VMINOR set to major.minor."""
try:
content = check_output(["hg", "cat", "-r", "default", "lib/nss/nss.h"]).decode()
return re.search(
rf"#define\s+NSS_VMAJOR\s+{re.escape(major)}\b", content
) and re.search(rf"#define\s+NSS_VMINOR\s+{re.escape(minor)}\b", content)
except Exception:
return False
def node_set(revset):
"""Return the set of short hashes matching revset."""
try:
result = (
check_output(["hg", "log", "-r", revset, "--template", "{node|short}\\n"])
.decode()
.strip()
)
except Exception:
return set()
return set(result.split()) if result else set()
def graft_sources_on_branch(branch):
"""Return short hashes of default-branch commits grafted onto branch.
These are the source= values recorded by hg graft, truncated to 12 chars
to match the {node|short} format used elsewhere.
"""
try:
extras = check_output(
["hg", "log", "-r", f"::'{branch}'", "--template", "{extras}\\n"]
).decode()
except Exception:
return set()
return {h[:12] for h in re.findall(r"(?<![a-z_])source=([0-9a-f]+)", extras)}
def find_beta_bump_commit(upper, prev_branch, major, minor):
"""Find the commit that first set lib/nss/nss.h to version {major}.{minor} Beta.
Only searches commits reachable from upper but not from prev_branch, so it
returns quickly when no beta bump was made.
Returns the short hash of the commit, or None if not found.
"""
try:
cmd = [
"hg",
"log",
"-r",
f"filelog('lib/nss/nss.h') and ::'{upper}' and not ::'{prev_branch}'",
"--template",
"{node|short}\\n",
]
result = check_output(cmd).decode().strip()
except Exception as e:
exit_with_failure(f"Failed to get nss.h history: {e}")
if not result:
return None
commits = [c for c in result.split("\n") if c] # hg log output is newest first
# Search from oldest to newest to find the first commit showing this version as beta
for commit in reversed(commits):
try:
content = check_output(
["hg", "cat", "-r", commit, "lib/nss/nss.h"]
).decode()
except Exception:
continue
if (
re.search(rf"#define\s+NSS_VMAJOR\s+{re.escape(major)}\b", content)
and re.search(rf"#define\s+NSS_VMINOR\s+{re.escape(minor)}\b", content)
and re.search(r"#define\s+NSS_BETA\s+PR_TRUE", content)
):
return commit
return None
def extract_bug_ids(bug_lines):
"""Extract integer bug IDs from formatted 'Bug N - description.' lines."""
seen = set()
ids = []
for line in bug_lines:
m = re.match(r"Bug\s+(\d+)", line, re.IGNORECASE)
if m:
bid = int(m.group(1))
if bid not in seen:
seen.add(bid)
ids.append(bid)
return ids
def get_bug_list_for_version(version):
"""Extract bug changes from Mercurial log for the given release version.
For point releases (a.b.c), uses the previous RTM tag (NSS_A_B_RTM for
3.x.1, NSS_A_B_{C-1}_RTM for later point releases) as the base.
For regular releases (a.b), finds the commit that bumped lib/nss/nss.h to
version a.b Beta and collects all commits after it on the release branch.
Falls back to comparing with NSS_A_(B-1)_BRANCH if no beta bump is found.
"""
parts = version.split(".")
if len(parts) < 2:
exit_with_failure(f"Invalid version format: {version}")
major, minor = parts[0], parts[1]
branch_name = f"NSS_{major}_{minor}_BRANCH"
rtm_tag = version_string_to_RTM_tag(version)
if tag_exists(rtm_tag):
upper = rtm_tag
elif tag_exists(branch_name):
upper = branch_name
elif default_branch_has_version(major, minor):
print(f"Branch {branch_name} not yet created; using default branch.")
upper = "default"
else:
exit_with_failure(
f"Cannot find branch {branch_name} and default does not contain NSS {version}."
)
if len(parts) == 3:
patch = int(parts[2])
prev_version = (
f"{major}.{minor}" if patch == 1 else f"{major}.{minor}.{patch - 1}"
)
prev_tag = version_string_to_RTM_tag(prev_version)
print(f"Point release: collecting commits after {prev_tag} on {upper}.")
revset = f"descendants('{prev_tag}') and ::'{upper}' and not '{prev_tag}'"
grafted_away = set()
else:
prev_branch = f"NSS_{major}_{int(minor) - 1}_BRANCH"
revset = f"::'{upper}' and not ::'{prev_branch}'"
beta_bump = find_beta_bump_commit(upper, prev_branch, major, minor)
if beta_bump:
print(f"Found {version} beta version bump at {beta_bump}.")
# Commits before the beta bump may have been grafted to the previous
# branch for a point release; those belong to the previous version.
grafted_to_prev = graft_sources_on_branch(prev_branch)
pre_bump_nodes = node_set(
f"::'{beta_bump}' and not ::'{prev_branch}' and not '{beta_bump}'"
)
grafted_away = pre_bump_nodes & grafted_to_prev
else:
print(f"Warning: No {version} beta version bump found in lib/nss/nss.h.")
grafted_away = set()
try:
command = [
"hg",
"log",
"-r",
revset,
"--template",
"{node|short}\\t{desc|firstline}\\n",
]
log_output = check_output(command).decode("utf-8")
except Exception as e:
exit_with_failure(f"Failed to get hg log: {e}")
commits = []
for line in log_output.split("\n"):
if "\t" in line:
node, title = line.split("\t", 1)
commits.append((node.strip(), title.strip()))
# Collect hashes that were backed out within this range
backed_out = set()
for _node, title in commits:
m = re.search(r"\bBacked out changeset ([0-9a-f]+)\b", title, re.IGNORECASE)
if m:
backed_out.add(m.group(1))
bug_lines = []
for node, title in commits:
if node in backed_out:
continue # this commit was backed out; skip it
if re.search(r"\bBacked out changeset\b", title, re.IGNORECASE):
continue # this is a backout commit; skip it
if node in grafted_away:
continue # pre-bump commit grafted to previous branch; belongs to previous version
if not re.match(r"bug\s+\d+", title, re.IGNORECASE):
continue
line = title
# Remove reviewer info from tail: r=, r?, or r! (with optional leading comma)
line = re.sub(r",?\s+r[=?!]\S+$", "", line).strip()
# Normalize "Bug N:" to "Bug N -"
line = re.sub(r"(Bug\s+\d+):", r"\1 -", line, flags=re.IGNORECASE)
# Ensure "Bug N - description" format (add dash if missing)
line = re.sub(r"(Bug\s+\d+)\s+([^-])", r"\1 - \2", line, flags=re.IGNORECASE)
line = line.rstrip(",").strip()
if line and not line.endswith("."):
line = line + "."
if line and line not in bug_lines:
bug_lines.append(line)
return list(reversed(bug_lines))