mirror of
https://github.com/fmtlib/fmt.git
synced 2026-06-15 00:16:15 +08:00
841040e781
Draft releases do not fire the `release: created` event, so the release workflow never ran and the source zip and SLSA provenance were not attached to the draft. Trigger the workflow explicitly from release.py via workflow_dispatch, passing the tag to attach to and the ref to build from, and resolve the tag/ref in the workflow for both event types.
230 lines
8.0 KiB
Python
Executable File
230 lines
8.0 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
"""Make a release.
|
|
|
|
Usage:
|
|
release.py [<branch>]
|
|
|
|
For the release command $FMT_TOKEN should contain a GitHub personal access token
|
|
obtained from https://github.com/settings/tokens.
|
|
"""
|
|
|
|
from __future__ import print_function
|
|
import datetime, docopt, errno, fileinput, json, os
|
|
import re, shutil, sys
|
|
from subprocess import check_call
|
|
import urllib.request
|
|
|
|
|
|
class Git:
|
|
def __init__(self, dir):
|
|
self.dir = dir
|
|
|
|
def call(self, method, args, **kwargs):
|
|
return check_call(['git', method] + list(args), **kwargs)
|
|
|
|
def add(self, *args):
|
|
return self.call('add', args, cwd=self.dir)
|
|
|
|
def checkout(self, *args):
|
|
return self.call('checkout', args, cwd=self.dir)
|
|
|
|
def clean(self, *args):
|
|
return self.call('clean', args, cwd=self.dir)
|
|
|
|
def clone(self, *args):
|
|
return self.call('clone', list(args) + [self.dir])
|
|
|
|
def fetch(self, *args):
|
|
return self.call('fetch', args, cwd=self.dir)
|
|
|
|
def commit(self, *args):
|
|
return self.call('commit', args, cwd=self.dir)
|
|
|
|
def pull(self, *args):
|
|
return self.call('pull', args, cwd=self.dir)
|
|
|
|
def push(self, *args):
|
|
return self.call('push', args, cwd=self.dir)
|
|
|
|
def reset(self, *args):
|
|
return self.call('reset', args, cwd=self.dir)
|
|
|
|
def update(self, *args):
|
|
clone = not os.path.exists(self.dir)
|
|
if clone:
|
|
self.clone(*args)
|
|
return clone
|
|
|
|
|
|
def clean_checkout(repo, branch):
|
|
repo.clean('-f', '-d')
|
|
repo.fetch('origin')
|
|
repo.checkout(branch)
|
|
# Hard-reset to the remote so a reused clone picks up new commits
|
|
# instead of building from stale local state.
|
|
repo.reset('--hard', 'origin/' + branch)
|
|
|
|
|
|
class Runner:
|
|
def __init__(self, cwd, env=None):
|
|
self.cwd = cwd
|
|
self.env = env
|
|
|
|
def __call__(self, *args, **kwargs):
|
|
kwargs['cwd'] = kwargs.get('cwd', self.cwd)
|
|
if self.env is not None:
|
|
kwargs['env'] = kwargs.get('env', self.env)
|
|
check_call(args, **kwargs)
|
|
|
|
|
|
def create_build_env():
|
|
"""Create a build environment."""
|
|
class Env:
|
|
pass
|
|
env = Env()
|
|
env.fmt_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
|
env.build_dir = 'build'
|
|
env.fmt_repo = Git(os.path.join(env.build_dir, 'fmt'))
|
|
return env
|
|
|
|
|
|
def create_doc_env(env, fmt_repo):
|
|
"""Create a virtualenv with the pinned documentation dependencies and
|
|
return an environment dict with it prepended to PATH. This ensures the
|
|
docs are built with the exact mkdocs/mkdocstrings versions required by the
|
|
custom handler, regardless of what is installed system-wide."""
|
|
# Use an absolute path so the venv resolves on PATH regardless of the
|
|
# working directory the build steps run in.
|
|
venv_dir = os.path.abspath(os.path.join(env.build_dir, 'venv'))
|
|
shutil.rmtree(venv_dir, ignore_errors=True)
|
|
check_call([sys.executable, '-m', 'venv', venv_dir])
|
|
venv_bin = os.path.join(venv_dir, 'bin')
|
|
pip = os.path.join(venv_bin, 'pip')
|
|
check_call([pip, 'install', '--quiet', '--upgrade', 'pip'])
|
|
requirements = os.path.join(
|
|
fmt_repo.dir, 'support', 'doc-requirements.txt')
|
|
check_call(
|
|
[pip, 'install', '--quiet', '--require-hashes', '-r', requirements])
|
|
doc_env = os.environ.copy()
|
|
doc_env['PATH'] = venv_bin + os.pathsep + doc_env.get('PATH', '')
|
|
return doc_env
|
|
|
|
|
|
if __name__ == '__main__':
|
|
args = docopt.docopt(__doc__)
|
|
env = create_build_env()
|
|
fmt_repo = env.fmt_repo
|
|
|
|
branch = args.get('<branch>')
|
|
if branch is None:
|
|
branch = 'main'
|
|
if not fmt_repo.update('-b', branch, 'git@github.com:fmtlib/fmt'):
|
|
clean_checkout(fmt_repo, branch)
|
|
|
|
# Update the date in the changelog and extract the version and the first
|
|
# section content.
|
|
changelog = 'ChangeLog.md'
|
|
changelog_path = os.path.join(fmt_repo.dir, changelog)
|
|
is_first_section = True
|
|
first_section = []
|
|
for i, line in enumerate(fileinput.input(changelog_path, inplace=True)):
|
|
if i == 0:
|
|
version = re.match(r'# (.*) - TBD', line).group(1)
|
|
line = '# {} - {}\n'.format(
|
|
version, datetime.date.today().isoformat())
|
|
elif not is_first_section:
|
|
pass
|
|
elif line.startswith('#'):
|
|
is_first_section = False
|
|
else:
|
|
first_section.append(line)
|
|
sys.stdout.write(line)
|
|
if first_section[0] == '\n':
|
|
first_section.pop(0)
|
|
|
|
ns_version = None
|
|
base_h_path = os.path.join(fmt_repo.dir, 'include', 'fmt', 'base.h')
|
|
for line in fileinput.input(base_h_path):
|
|
m = re.match(r'\s*inline namespace v(.*) .*', line)
|
|
if m:
|
|
ns_version = m.group(1)
|
|
break
|
|
major_version = version.split('.')[0]
|
|
if not ns_version or ns_version != major_version:
|
|
raise Exception(f'Version mismatch {ns_version} != {major_version}')
|
|
|
|
# Workaround GitHub-flavored Markdown treating newlines as <br>.
|
|
changes = ''
|
|
code_block = False
|
|
stripped = False
|
|
for line in first_section:
|
|
if re.match(r'^\s*```', line):
|
|
code_block = not code_block
|
|
changes += line
|
|
stripped = False
|
|
continue
|
|
if code_block:
|
|
changes += line
|
|
continue
|
|
if line == '\n' or re.match(r'^\s*\|.*', line):
|
|
if stripped:
|
|
changes += '\n'
|
|
stripped = False
|
|
changes += line
|
|
continue
|
|
if stripped:
|
|
line = ' ' + line.lstrip()
|
|
changes += line.rstrip()
|
|
stripped = True
|
|
|
|
fmt_repo.checkout('-B', 'release')
|
|
fmt_repo.add(changelog)
|
|
fmt_repo.commit('-m', 'Update version')
|
|
|
|
# Build the docs locally in a virtualenv with the pinned doc dependencies;
|
|
# the source zip is now built and attached to the release in CI by
|
|
# .github/workflows/release.yml, which also generates a SLSA provenance
|
|
# attestation for it. The venv is prepended to PATH so that CMake's
|
|
# find_program(MKDOCS mkdocs) and the ./mkdocs deploy step below both pick
|
|
# up the correct mkdocs/mkdocstrings versions.
|
|
doc_env = create_doc_env(env, fmt_repo)
|
|
run = Runner(fmt_repo.dir, env=doc_env)
|
|
run('cmake', '.')
|
|
run('make', 'doc')
|
|
|
|
# Create a draft release on GitHub, then trigger the release workflow to
|
|
# build the source zip from the `release` branch and attach the zip plus
|
|
# *.intoto.jsonl provenance to this draft. After reviewing the draft, the
|
|
# maintainer clicks Publish to finalize.
|
|
fmt_repo.push('origin', 'release')
|
|
auth_headers = {'Authorization': 'token ' + os.getenv('FMT_TOKEN')}
|
|
req = urllib.request.Request(
|
|
'https://api.github.com/repos/fmtlib/fmt/releases',
|
|
data=json.dumps({'tag_name': version,
|
|
'target_commitish': 'release',
|
|
'body': changes, 'draft': True}).encode('utf-8'),
|
|
headers=auth_headers, method='POST')
|
|
with urllib.request.urlopen(req) as response:
|
|
if response.status != 201:
|
|
raise Exception(f'Failed to create a release ' +
|
|
'{response.status} {response.reason}')
|
|
|
|
# Draft releases do not fire `release: created`, so explicitly dispatch the
|
|
# release workflow. It runs from the default branch (`branch`) but builds
|
|
# and uploads artifacts from the `release` branch for tag `version`.
|
|
dispatch_req = urllib.request.Request(
|
|
'https://api.github.com/repos/fmtlib/fmt/actions/workflows/'
|
|
'release.yml/dispatches',
|
|
data=json.dumps({'ref': branch,
|
|
'inputs': {'tag_name': version,
|
|
'ref': 'release'}}).encode('utf-8'),
|
|
headers=auth_headers, method='POST')
|
|
with urllib.request.urlopen(dispatch_req) as response:
|
|
if response.status != 204:
|
|
raise Exception('Failed to dispatch the release workflow ' +
|
|
f'{response.status} {response.reason}')
|
|
|
|
short_version = '.'.join(version.split('.')[:-1])
|
|
check_call(['./mkdocs', 'deploy', short_version], env=doc_env)
|