rust_realease/worker/cli.py

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