150 lines
9.2 KiB
Python
150 lines
9.2 KiB
Python
"""CLI argument handling and ordered release orchestration."""
|
|
import os
|
|
from pathlib import Path
|
|
import traceback
|
|
import typer
|
|
from . import runner
|
|
from .build import build, prerequisites, verify_source
|
|
from .config import DEFAULT_CONFIG, load_config
|
|
from .gitea import Gitea
|
|
from .manifest import inspect_project, metadata_issues, repair_metadata
|
|
from .models import Stage
|
|
from .prepare import prepare_repository
|
|
from .package import package
|
|
from .policy import archive_name, expected_tag
|
|
from .project import acquire_project, origin_url, parse_repository, validate_checkout_tag
|
|
from .verify import verify_binstall, verify_published
|
|
|
|
app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False)
|
|
console = runner.console
|
|
|
|
|
|
@app.command()
|
|
def release(
|
|
source: str = typer.Argument(..., help='Local directory or HTTP(S)/SSH Git URL.'),
|
|
package_name: str | None = typer.Option(None, '--package', help='Exact workspace package name; required for workspaces.'),
|
|
tag: str | None = typer.Option(None, '--tag', '-t'),
|
|
tag_prefix: str | None = typer.Option(None, '--tag-prefix', help='Override version tag prefix; use an empty string for unprefixed tags.'),
|
|
target: list[str] | None = typer.Option(None, '--target', help='Rust target; repeatable.'),
|
|
dry_run: bool = typer.Option(False, '--dry-run'),
|
|
fix_metadata: bool = typer.Option(False, '--fix-metadata'),
|
|
prepare_repo: bool = typer.Option(False, '--prepare-repo', help='Prepare release inputs, then exit without publishing.'),
|
|
commit_preparation: bool = typer.Option(False, '--commit-preparation', help='Commit prepared files; requires a clean checkout.'),
|
|
create_tag: bool = typer.Option(False, '--create-tag', help='Create the version tag after committing preparation; never move tags.'),
|
|
push_preparation: bool = typer.Option(False, '--push-preparation', help='Atomically push prepared branch and tag to origin.'),
|
|
cross_image_tag: str | None = typer.Option(None, '--cross-image-tag', help='Set cross image tags during preparation, e.g. main.'),
|
|
skip_tests: bool = typer.Option(False, '--skip-tests', help='Skip cargo test; cargo check still runs.'),
|
|
skip_binstall_test: bool = typer.Option(False, '--skip-binstall-test'),
|
|
draft: bool = typer.Option(False, '--draft'),
|
|
prerelease: bool = typer.Option(False, '--prerelease'),
|
|
replace_assets: bool = typer.Option(False, '--replace-assets'),
|
|
keep_workdir: bool = typer.Option(False, '--keep-workdir'),
|
|
verbose: bool = typer.Option(False, '--verbose'),
|
|
stop_after: Stage | None = typer.Option(None, '--stop-after'),
|
|
config: Path = typer.Option(DEFAULT_CONFIG, '--config'),
|
|
profile: str | None = typer.Option(None, '--profile'),
|
|
unlocked: bool = typer.Option(False, '--unlocked'),
|
|
repository_url: str | None = typer.Option(None, '--repository-url', help='Explicit Gitea web repository URL.'),
|
|
):
|
|
runner.verbose = verbose
|
|
try:
|
|
settings = load_config(config, targets=target or None, profile=profile, locked=False if unlocked else None, tag_prefix=tag_prefix)
|
|
runner.register_secret(settings.token_env)
|
|
if (commit_preparation or create_tag or push_preparation or cross_image_tag is not None) and not prepare_repo:
|
|
raise ValueError('Preparation options require --prepare-repo.')
|
|
if prepare_repo and stop_after is not None:
|
|
raise ValueError('--prepare-repo is a separate mode; omit --stop-after.')
|
|
with acquire_project(source, None if prepare_repo else tag, keep_workdir or prepare_repo) as root:
|
|
project = inspect_project(root, package_name)
|
|
release_tag = expected_tag(project.version, settings.tag_prefix)
|
|
if tag is not None and tag != release_tag:
|
|
raise ValueError(f'Tag {tag!r} does not match package version; expected {release_tag!r}.')
|
|
project.tag = release_tag
|
|
publishing = not prepare_repo and not dry_run and stop_after not in (Stage.inspect, Stage.metadata, Stage.verify, Stage.build, Stage.package)
|
|
if publishing and runner.run('git', 'status', '--porcelain', '--untracked-files=normal', cwd=root):
|
|
raise ValueError('Publication requires a clean checkout before metadata repair.')
|
|
displayed_repository = 'missing'
|
|
if project.repository:
|
|
try:
|
|
displayed_repository = parse_repository(project.repository).url
|
|
except ValueError:
|
|
displayed_repository = 'invalid (use --repository-url to repair)'
|
|
for key, value in [('Package', project.package_name), ('Version', project.version),
|
|
('Repository', displayed_repository), ('Binary', project.binaries[0]),
|
|
('Manifest', str(project.manifest)), ('Commit', project.commit or 'unknown'), ('Tag', release_tag)]:
|
|
console.print(f'{key}: {value}')
|
|
if stop_after == Stage.inspect:
|
|
return
|
|
candidate = repository_url or project.repository or origin_url(root)
|
|
if not candidate:
|
|
raise ValueError('package.repository is missing; provide --repository-url and --fix-metadata.')
|
|
repository = parse_repository(candidate)
|
|
if prepare_repo:
|
|
prepare_repository(project, settings, repository, image_tag=cross_image_tag,
|
|
dry_run=dry_run, commit=commit_preparation,
|
|
create_tag=create_tag, push=push_preparation)
|
|
return
|
|
issues = metadata_issues(project.manifest, repository.url, settings.tag_prefix)
|
|
for issue in issues:
|
|
console.print(runner.redact(f'{issue.key}: {issue.actual!r} -> {issue.expected!r}'))
|
|
if not issues:
|
|
console.print('Binstall metadata: valid')
|
|
if issues and fix_metadata and not dry_run:
|
|
repair_metadata(project.manifest, issues)
|
|
console.print('Metadata repaired locally. Commit and push explicitly if desired.')
|
|
if issues and not fix_metadata and not dry_run:
|
|
raise ValueError('Metadata requires repair. Rerun with --fix-metadata.')
|
|
if stop_after == Stage.metadata:
|
|
return
|
|
problems, engine = prerequisites(project, settings, not skip_binstall_test and stop_after not in (Stage.verify, Stage.build, Stage.package, Stage.release, Stage.upload))
|
|
tag_exists = validate_checkout_tag(root, release_tag, required=False)
|
|
if not tag_exists:
|
|
problems.append(f'Git tag {release_tag!r} is missing; create it explicitly before publishing')
|
|
console.print(f'Release destination: {repository.url}/releases/tag/{release_tag}')
|
|
for triple in settings.targets:
|
|
console.print(f'{triple}: {archive_name(project.package_name, triple, project.version)}')
|
|
for problem in problems:
|
|
console.print('Prerequisite: ' + problem)
|
|
if dry_run:
|
|
console.print('Dry run complete: no manifest edits, builds or release mutations.')
|
|
if issues or problems:
|
|
raise ValueError('Dry run found the metadata/prerequisite issues reported above.')
|
|
return
|
|
# Missing tags only prevent publishing; package-only work is useful before tagging.
|
|
build_problems = [p for p in problems if not p.startswith('Git tag ')]
|
|
if build_problems:
|
|
raise ValueError('Resolve the prerequisite issues above before building.')
|
|
if publishing:
|
|
validate_checkout_tag(root, release_tag)
|
|
if not os.environ.get(settings.token_env):
|
|
raise ValueError(f'Set {settings.token_env} before publishing.')
|
|
verify_source(project, settings, skip_tests)
|
|
if stop_after == Stage.verify:
|
|
return
|
|
outputs = build(project, settings, engine)
|
|
if stop_after == Stage.build:
|
|
return
|
|
artifacts, sums = package(project, outputs)
|
|
console.print(f'Artifacts: {sums.parent}')
|
|
if stop_after == Stage.package:
|
|
return
|
|
with Gitea(repository, settings.token_env) as api:
|
|
remote_release = api.ensure_release(release_tag, project.commit, draft, prerelease)
|
|
console.print(f'Release ready: {release_tag}')
|
|
if stop_after == Stage.release:
|
|
return
|
|
api.upload(remote_release['id'], [a.path for a in artifacts] + [sums], replace_assets)
|
|
if stop_after == Stage.upload:
|
|
return
|
|
if remote_release.get('draft'):
|
|
raise ValueError('Draft uploaded. Public verification requires publishing the draft; use --stop-after upload for draft workflows.')
|
|
verify_published(repository.url, release_tag, artifacts, sums)
|
|
if not skip_binstall_test:
|
|
verify_binstall(project, settings.targets)
|
|
console.print('Release completed and published artifacts verified.')
|
|
except Exception as exc:
|
|
if verbose:
|
|
console.print(runner.redact(traceback.format_exc()))
|
|
console.print('error: ' + runner.redact(str(exc)))
|
|
raise typer.Exit(1) from None
|