You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tooling.apache.org by ar...@apache.org on 2026/03/05 11:17:32 UTC
(tooling-trusted-releases) 03/03: Latest changes - note: broken
This is an automated email from the ASF dual-hosted git repository.
arm pushed a commit to branch taint_tracking_types
in repository https://gitbox.apache.org/repos/asf/tooling-trusted-releases.git
commit 34b19fed7495006153e3e697a4f9b17716a09b18
Author: Alastair McFarlane <ar...@apache.org>
AuthorDate: Wed Mar 4 16:25:13 2026 +0000
Latest changes - note: broken
---
atr/admin/__init__.py | 31 +++--
atr/api/__init__.py | 44 ++++---
atr/attestable.py | 47 ++++---
atr/blueprints/api.py | 50 ++++++--
atr/blueprints/common.py | 72 ++++++-----
atr/blueprints/post.py | 3 +
atr/cache.py | 2 +-
atr/construct.py | 77 ++++++------
atr/datasources/apache.py | 8 +-
atr/db/__init__.py | 5 +-
atr/db/interaction.py | 50 +++++---
atr/get/announce.py | 20 +--
atr/get/checklist.py | 2 +-
atr/get/checks.py | 14 +--
atr/get/distribution.py | 66 +++++-----
atr/get/download.py | 20 +--
atr/get/draft.py | 2 +-
atr/get/file.py | 22 ++--
atr/get/finish.py | 44 +++----
atr/get/ignores.py | 2 +-
atr/get/manual.py | 6 +-
atr/get/projects.py | 46 +++----
atr/get/report.py | 8 +-
atr/get/result.py | 2 +-
atr/get/revisions.py | 6 +-
atr/get/sbom.py | 22 ++--
atr/get/start.py | 2 +-
atr/get/test.py | 18 +--
atr/get/upload.py | 4 +-
atr/get/vote.py | 12 +-
atr/get/voting.py | 10 +-
atr/merge.py | 17 +--
atr/models/__init__.py | 3 +-
atr/models/api.py | 62 ++++-----
atr/models/results.py | 14 +--
atr/models/safe.py | 84 +++++++++++++
atr/models/sql.py | 95 ++++++++++++--
atr/paths.py | 27 ++--
atr/post/announce.py | 12 +-
atr/post/distribution.py | 38 +++---
atr/post/draft.py | 36 +++---
atr/post/finish.py | 26 ++--
atr/post/ignores.py | 18 +--
atr/post/keys.py | 4 +-
atr/post/manual.py | 14 +--
atr/post/projects.py | 24 ++--
atr/post/resolve.py | 15 ++-
atr/post/revisions.py | 22 ++--
atr/post/sbom.py | 12 +-
atr/post/start.py | 4 +-
atr/post/upload.py | 20 +--
atr/post/vote.py | 2 +-
atr/post/voting.py | 20 +--
atr/shared/distribution.py | 19 +--
atr/shared/projects.py | 19 +--
atr/shared/web.py | 133 +++++++++++---------
atr/ssh.py | 168 +++++++++++++------------
atr/storage/__init__.py | 23 ++--
atr/storage/readers/checks.py | 13 +-
atr/storage/readers/releases.py | 2 +-
atr/storage/writers/announce.py | 17 +--
atr/storage/writers/checks.py | 7 +-
atr/storage/writers/distributions.py | 30 ++---
atr/storage/writers/keys.py | 11 +-
atr/storage/writers/policy.py | 12 +-
atr/storage/writers/project.py | 21 ++--
atr/storage/writers/release.py | 102 +++++++++------
atr/storage/writers/revision.py | 36 +++---
atr/storage/writers/sbom.py | 25 ++--
atr/storage/writers/ssh.py | 7 +-
atr/storage/writers/vote.py | 55 ++++----
atr/storage/writers/workflowstatus.py | 7 +-
atr/tasks/__init__.py | 43 ++++---
atr/tasks/checks/__init__.py | 38 +++---
atr/tasks/checks/compare.py | 3 +-
atr/tasks/distribution.py | 4 +-
atr/tasks/gha.py | 5 +-
atr/tasks/keys.py | 5 +-
atr/tasks/quarantine.py | 11 +-
atr/tasks/sbom.py | 17 +--
atr/tasks/svn.py | 5 +-
atr/tasks/vote.py | 17 ++-
atr/templates/check-selected-path-table.html | 20 +--
atr/templates/check-selected-release-info.html | 36 +++---
atr/templates/check-selected.html | 6 +-
atr/templates/committee-directory.html | 4 +-
atr/templates/committee-view.html | 2 +-
atr/templates/download-all.html | 10 +-
atr/templates/draft-tools.html | 2 +-
atr/templates/includes/topnav.html | 4 +-
atr/templates/index-committer.html | 8 +-
atr/templates/project-select.html | 6 +-
atr/templates/projects.html | 4 +-
atr/templates/release-select.html | 6 +-
atr/templates/releases-finished.html | 4 +-
atr/templates/releases.html | 2 +-
atr/templates/report-selected-path.html | 8 +-
atr/templates/resolve-tabulated.html | 2 +-
atr/validate.py | 4 +-
atr/web.py | 12 +-
atr/worker.py | 13 +-
101 files changed, 1327 insertions(+), 967 deletions(-)
diff --git a/atr/admin/__init__.py b/atr/admin/__init__.py
index 6a759d93..a14f31bd 100644
--- a/atr/admin/__init__.py
+++ b/atr/admin/__init__.py
@@ -47,6 +47,7 @@ import atr.htm as htm
import atr.ldap as ldap
import atr.log as log
import atr.mapping as mapping
+import atr.models.safe as safe
import atr.models.session
import atr.models.sql as sql
import atr.paths as paths
@@ -328,11 +329,11 @@ async def delete_release_get(session: web.Committer) -> str | web.WerkzeugRespon
class_="form-check-input",
type="checkbox",
name="releases_to_delete",
- value=release.name,
+ value=str(release.name),
id=f"release_{release.name}",
),
htpy.label(".form-check-label", for_=f"release_{release.name}")[
- htpy.strong[release.name],
+ htpy.strong[str(release.name)],
f" ({release.project.display_name}, {release.phase.value.upper()})",
],
]
@@ -581,14 +582,18 @@ async def logs(session: web.Committer) -> web.QuartResponse:
async def ongoing_tasks_get(
session: web.Committer, project_name: str, version_name: str, revision: str
) -> web.QuartResponse:
- return await _ongoing_tasks(session, project_name, version_name, revision)
+ project = safe.ProjectName(project_name)
+ version = safe.VersionName(version_name)
+ return await _ongoing_tasks(session, project, version, revision)
@admin.post("/ongoing-tasks/<project_name>/<version_name>/<revision>")
async def ongoing_tasks_post(
session: web.Committer, project_name: str, version_name: str, revision: str
) -> web.QuartResponse:
- return await _ongoing_tasks(session, project_name, version_name, revision)
+ project = safe.ProjectName(project_name)
+ version = safe.VersionName(version_name)
+ return await _ongoing_tasks(session, project, version, revision)
@admin.get("/performance")
@@ -760,7 +765,9 @@ async def task_times(
values = []
async with db.session() as data:
tasks = await data.task(
- project_name=project_name, version_name=version_name, revision_number=revision_number
+ project_name=project_name,
+ version_name=version_name,
+ revision_number=revision_number,
).all()
for task in tasks:
if (task.started is None) or (task.completed is None):
@@ -840,8 +847,8 @@ async def tasks_recent(session: web.Committer, minutes: int) -> str:
htpy.td[task.status.value],
htpy.td[task.added.strftime("%H:%M:%S") if task.added else ""],
htpy.td[took_text],
- htpy.td[task.project_name or ""],
- htpy.td[task.version_name or ""],
+ htpy.td[str(task.project_name) or ""],
+ htpy.td[str(task.version_name) or ""],
htpy.td[task.revision_number or ""],
htpy.td[error_text],
]
@@ -873,8 +880,8 @@ async def tasks_recent(session: web.Committer, minutes: int) -> str:
htpy.td[task.task_type.value],
htpy.td[task.added.strftime("%Y-%m-%d %H:%M:%S") if task.added else ""],
htpy.td[task.scheduled.strftime("%Y-%m-%d %H:%M:%S") if task.scheduled else ""],
- htpy.td[task.project_name or ""],
- htpy.td[task.version_name or ""],
+ htpy.td[str(task.project_name) or ""],
+ htpy.td[str(task.version_name) or ""],
htpy.td[task.revision_number or ""],
]
)
@@ -1015,7 +1022,7 @@ async def _delete_releases(session: web.Committer, releases_to_delete: list[str]
raise RuntimeError(f"Release {release_name} has no committee")
async with storage.write(session) as write:
waca = write.as_committee_admin(release.committee.name)
- error = await waca.release.delete(release.project.name, release.version)
+ error = await waca.release.delete(release.safe_project_name.name, release.safe_version_name)
# Ensure that deletion errors are reported to the user
if error is not None:
raise RuntimeError(error)
@@ -1085,13 +1092,13 @@ async def _get_filesystem_dirs_unfinished(filesystem_dirs: list[str]) -> None:
async def _ongoing_tasks(
- session: web.Committer, project_name: str, version_name: str, revision: str
+ session: web.Committer, project_name: safe.ProjectName, version_name: safe.VersionName, revision: str
) -> web.QuartResponse:
try:
ongoing = await interaction.tasks_ongoing(project_name, version_name, revision)
return web.TextResponse(str(ongoing))
except Exception:
- log.exception(f"Error fetching ongoing task count for {project_name} {version_name} rev {revision}:")
+ log.exception(f"Error fetching ongoing task count for {project_name!s} {version_name!s} rev {revision}:")
return web.TextResponse("")
diff --git a/atr/api/__init__.py b/atr/api/__init__.py
index b11259f5..86a4360d 100644
--- a/atr/api/__init__.py
+++ b/atr/api/__init__.py
@@ -154,7 +154,7 @@ async def checks_ongoing(
cannot be promoted to the vote phase if checks are still ongoing.
"""
ongoing_tasks_count, _latest_revision = await interaction.tasks_ongoing_revision(
- str(project_name), str(version_name), revision
+ project_name, version_name, revision
)
# TODO: Is there a way to return just an int?
# The ResponseReturnValue type in quart does not allow int
@@ -295,7 +295,7 @@ async def distribute_ssh_register(
fingerprint, expires = await wacm.ssh.add_workflow_key(
payload["actor"],
payload["actor_id"],
- release.project_name,
+ release.safe_project_name,
data.ssh_key,
payload,
)
@@ -303,7 +303,7 @@ async def distribute_ssh_register(
return models.api.DistributeSshRegisterResults(
endpoint="/distribute/ssh/register",
fingerprint=fingerprint,
- project=release.project_name,
+ project=release.safe_project_name,
expires=expires,
).model_dump(), 200
@@ -323,13 +323,12 @@ async def distribution_record(
"""
asf_uid = _jwt_asf_uid()
async with db.session() as db_data:
- release_name = models.sql.release_name(data.project, data.version)
release = await db_data.release(
- project_name=data.project,
- version=data.version,
- ).demand(exceptions.NotFound(f"Release {release_name} not found"))
+ project_name=str(data.project),
+ version=str(data.version),
+ ).demand(exceptions.NotFound(f"Release {data.project!s} {data.version!s} not found"))
if release.committee is None:
- raise exceptions.NotFound(f"Release {release_name} has no committee")
+ raise exceptions.NotFound(f"Release {release.name} has no committee")
dd = models.distribution.Data(
platform=data.platform,
owner_namespace=data.distribution_owner_namespace,
@@ -340,7 +339,7 @@ async def distribution_record(
async with storage.write(asf_uid) as write:
wacm = write.as_committee_member(release.committee.name)
_dist, _added, metadata = await wacm.distributions.record_from_data(
- release.name,
+ release.safe_name,
data.staging,
dd,
)
@@ -383,7 +382,7 @@ async def distribution_record_from_workflow(
)
async with storage.write_as_committee_member(release.committee.name, asf_uid) as wacm:
_dist, _added, metadata = await wacm.distributions.record_from_data(
- release.name, data.staging, dd, allow_retries=True
+ release.safe_name, data.staging, dd, allow_retries=True
)
if metadata is None:
log.warning("Distribution could not be found, ATR will retry this automatically")
@@ -724,7 +723,7 @@ async def project_policy(
)
return models.api.ProjectPolicyResults(
endpoint="/project/policy",
- project_name=project.name,
+ project_name=project.safe_name,
policy_announce_release_subject=project.policy_announce_release_subject,
policy_announce_release_template=project.policy_announce_release_template,
policy_binary_artifact_paths=project.policy_binary_artifact_paths,
@@ -811,13 +810,12 @@ async def publisher_distribution_record(
interaction.TrustedProjectPhase.COMPOSE,
)
async with db.session() as db_data:
- release_name = models.sql.release_name(project.name, data.version)
release = await db_data.release(
project_name=project.name,
- version=data.version,
- ).demand(exceptions.NotFound(f"Release {release_name} not found"))
+ version=str(data.version),
+ ).demand(exceptions.NotFound(f"Release {project.name} {data.version!s} not found"))
if release.committee is None:
- raise exceptions.NotFound(f"Release {release_name} has no committee")
+ raise exceptions.NotFound(f"Release {release.name} has no committee")
dd = models.distribution.Data(
platform=data.platform,
owner_namespace=data.distribution_owner_namespace,
@@ -828,7 +826,7 @@ async def publisher_distribution_record(
async with storage.write(asf_uid) as write:
wacm = write.as_committee_member(release.committee.name)
await wacm.distributions.record_from_data(
- release.name,
+ release.safe_name,
data.staging,
dd,
)
@@ -859,7 +857,7 @@ async def publisher_release_announce(
committee = util.unwrap(project.committee)
async with storage.write_as_committee_member(committee.name, asf_uid) as wacm:
await wacm.announce.release(
- project_name=project.name,
+ project_name=project.safe_name,
version_name=data.version,
preview_revision_number=data.revision,
recipient=data.email_to,
@@ -895,7 +893,7 @@ async def publisher_ssh_register(
fingerprint, expires = await wacm.ssh.add_workflow_key(
payload["actor"],
payload["actor_id"],
- project.name,
+ project.safe_name,
data.ssh_key,
payload,
)
@@ -903,7 +901,7 @@ async def publisher_ssh_register(
return models.api.PublisherSshRegisterResults(
endpoint="/publisher/ssh/register",
fingerprint=fingerprint,
- project=project.name,
+ project=project.safe_name,
expires=expires,
).model_dump(), 200
@@ -924,11 +922,11 @@ async def publisher_vote_resolve(
data.jwt,
interaction.TrustedProjectPhase.VOTE,
)
- async with storage.write_as_project_committee_member(project.name, asf_uid) as wacm:
+ async with storage.write_as_project_committee_member(project.safe_name, asf_uid) as wacm:
# TODO: Get fullname and use instead of asf_uid
# TODO: Add resolution templating to atr.construct
_release, _voting_round, _success_message, _error_message = await wacm.vote.resolve(
- project.name,
+ project.safe_name,
data.version,
data.resolution,
asf_uid,
@@ -1399,7 +1397,7 @@ async def update_distribution_task_status(
async with db.session() as db_data:
status = await db_data.workflow_status(
workflow_id=data.workflow,
- project_name=data.project_name,
+ project_name=str(data.project_name),
run_id=int(data.run_id),
).demand(exceptions.NotFound(f"Workflow {data.workflow} not found"))
status.status = data.status
@@ -1580,7 +1578,7 @@ async def vote_tabulate(
# asf_uid = _jwt_asf_uid()
async with db.session() as db_data:
release_name = sql.release_name(data.project, data.version)
- release = await db_data.release(name=release_name, _project_release_policy=True).demand(
+ release = await db_data.release(name=str(release_name), _project_release_policy=True).demand(
exceptions.NotFound(f"Release {release_name} not found"),
)
diff --git a/atr/attestable.py b/atr/attestable.py
index 8114f249..f5e8592e 100644
--- a/atr/attestable.py
+++ b/atr/attestable.py
@@ -27,6 +27,7 @@ import pydantic
import atr.hashes as hashes
import atr.log as log
import atr.models.attestable as models
+import atr.models.safe as safe
import atr.paths as paths
import atr.util as util
@@ -34,32 +35,40 @@ if TYPE_CHECKING:
import pathlib
-def attestable_checks_path(project_name: str, version_name: str, revision_number: str) -> pathlib.Path:
- return paths.get_attestable_dir() / project_name / version_name / f"{revision_number}.checks.json"
+def attestable_checks_path(
+ project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str
+) -> pathlib.Path:
+ return paths.get_attestable_dir() / str(project_name) / str(version_name) / f"{revision_number}.checks.json"
-def attestable_path(project_name: str, version_name: str, revision_number: str) -> pathlib.Path:
- return paths.get_attestable_dir() / project_name / version_name / f"{revision_number}.json"
+def attestable_path(
+ project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str
+) -> pathlib.Path:
+ return paths.get_attestable_dir() / str(project_name) / str(version_name) / f"{revision_number}.json"
-def attestable_paths_path(project_name: str, version_name: str, revision_number: str) -> pathlib.Path:
- return paths.get_attestable_dir() / project_name / version_name / f"{revision_number}.paths.json"
+def attestable_paths_path(
+ project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str
+) -> pathlib.Path:
+ return paths.get_attestable_dir() / str(project_name) / str(version_name) / f"{revision_number}.paths.json"
-def github_tp_payload_path(project_name: str, version_name: str, revision_number: str) -> pathlib.Path:
- return paths.get_attestable_dir() / project_name / version_name / f"{revision_number}.github-tp.json"
+def github_tp_payload_path(
+ project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str
+) -> pathlib.Path:
+ return paths.get_attestable_dir() / str(project_name) / str(version_name) / f"{revision_number}.github-tp.json"
async def github_tp_payload_write(
- project_name: str, version_name: str, revision_number: str, github_payload: dict[str, Any]
+ project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str, github_payload: dict[str, Any]
) -> None:
payload_path = github_tp_payload_path(project_name, version_name, revision_number)
await util.atomic_write_file(payload_path, json.dumps(github_payload, indent=2))
async def load(
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
revision_number: str,
) -> models.AttestableV1 | None:
file_path = attestable_path(project_name, version_name, revision_number)
@@ -75,8 +84,8 @@ async def load(
async def load_checks(
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
revision_number: str,
) -> dict[str, dict[str, str]]:
file_path = attestable_checks_path(project_name, version_name, revision_number)
@@ -97,8 +106,8 @@ async def load_checks(
async def load_paths(
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
revision_number: str,
) -> dict[str, str] | None:
file_path = attestable_paths_path(project_name, version_name, revision_number)
@@ -163,8 +172,8 @@ async def paths_to_hashes_and_sizes(directory: pathlib.Path) -> tuple[dict[str,
async def write_checks_data(
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
revision_number: str,
rel_path: str,
checks: dict[str, str],
@@ -187,8 +196,8 @@ async def write_checks_data(
async def write_files_data(
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
revision_number: str,
release_policy: dict[str, Any] | None,
uploader_uid: str,
diff --git a/atr/blueprints/api.py b/atr/blueprints/api.py
index 1219b791..5df652e7 100644
--- a/atr/blueprints/api.py
+++ b/atr/blueprints/api.py
@@ -69,6 +69,8 @@ def typed(func: Callable[..., Any]) -> Callable[..., Any]:
original = inspect.unwrap(func)
path, validated_params, literal_params, body_param, query_param, optional_params = common.build_api_path(original)
method = "POST" if body_param is not None else "GET"
+ body_safe_params = common.safe_params_for_type(body_param[1]) if body_param is not None else []
+ query_safe_params = common.safe_params_for_type(query_param[1]) if query_param is not None else []
async def wrapper(*_args: Any, **kwargs: Any) -> Any:
await common.run_validators(kwargs, validated_params)
@@ -78,13 +80,19 @@ def typed(func: Callable[..., Any]) -> Callable[..., Any]:
body_name, body_cls = body_param
json_data = await quart.request.get_json()
try:
- kwargs[body_name] = body_cls.model_validate(json_data)
+ body_instance = body_cls.model_validate(json_data)
except pydantic.ValidationError as e:
raise quart_schema.RequestSchemaValidationError(e) from e
+ if body_safe_params:
+ await common.validate_safe_fields(body_instance, body_safe_params, kwargs)
+ kwargs[body_name] = body_instance
if query_param is not None:
query_name, query_cls = query_param
- kwargs[query_name] = _parse_query_args(query_cls, quart.request.args)
+ query_instance = _parse_query_args(query_cls, quart.request.args)
+ if query_safe_params:
+ await common.validate_safe_fields(query_instance, query_safe_params, kwargs)
+ kwargs[query_name] = query_instance
start_time_ns = time.perf_counter_ns()
response = await func(**kwargs)
@@ -107,15 +115,34 @@ def typed(func: Callable[..., Any]) -> Callable[..., Any]:
# Examine `func` for quart attributes and re-attach to the wrapped function
# This makes sure the OpenAPI documentation is preserved
# Note: we don't update querystring or request as they're processed above using our detected types
- for attr in _QUART_ATTRIBUTES:
- if hasattr(func, attr):
- setattr(wrapper, attr, getattr(func, attr))
+ _copy_quart_attributes(func, wrapper)
# If there are optional params, we need two routes, one with the optional params omitted
# and one with them all present.
# AM 26/03/03: This actually only handles the case where there's some required and a single optional, but
# that's the only case that existed in the original code. Theoretically we could count the optional params and
# generate the correct number of routes, but that's lot of effort for little gain right now
+ _add_url_rules(wrapper, path, endpoint, method, optional_params)
+
+ common.register_route(original, "api", _routes)
+ return wrapper
+
+
+@_BLUEPRINT.before_request
+@rate_limiter.rate_limit(500, datetime.timedelta(hours=1))
+async def _api_rate_limit() -> None:
+ """Set API-wide rate limit"""
+ pass
+
+
+def _add_url_rules(
+ wrapper: Callable[..., Any],
+ path: str,
+ endpoint: str,
+ method: str,
+ optional_params: list[str],
+) -> None:
+ """Register URL rules for the wrapper, handling optional path params with a default short route."""
if optional_params:
required_segments = [
seg for seg in path.strip("/").split("/") if not any(seg == f"<{name}>" for name in optional_params)
@@ -127,15 +154,12 @@ def typed(func: Callable[..., Any]) -> Callable[..., Any]:
else:
_BLUEPRINT.add_url_rule(path, endpoint=endpoint, view_func=wrapper, methods=[method])
- common.register_route(original, "api", _routes)
- return wrapper
-
-@_BLUEPRINT.before_request
-@rate_limiter.rate_limit(500, datetime.timedelta(hours=1))
-async def _api_rate_limit() -> None:
- """Set API-wide rate limit"""
- pass
+def _copy_quart_attributes(src: Callable[..., Any], dst: Callable[..., Any]) -> None:
+ """Copy quart schema attributes from src to dst to preserve OpenAPI documentation."""
+ for attr in _QUART_ATTRIBUTES:
+ if hasattr(src, attr):
+ setattr(dst, attr, getattr(src, attr))
def _exempt_blueprint(app: base.QuartApp) -> None:
diff --git a/atr/blueprints/common.py b/atr/blueprints/common.py
index 00109b6d..0a3089bb 100644
--- a/atr/blueprints/common.py
+++ b/atr/blueprints/common.py
@@ -26,12 +26,9 @@ import asfquart.base as base
import asfquart.session
import pydantic
-import atr.cache as cache
-import atr.db as db
import atr.form as form
import atr.ldap as ldap
import atr.models.safe as safe
-import atr.models.sql as sql
import atr.models.unsafe as unsafe
import atr.web as web
@@ -190,42 +187,55 @@ def register_route(func: Callable[..., Any], prefix: str, routes: list[str]) ->
routes.append(f"{prefix}.{module_name}.{func.__name__}")
+def safe_params_for_type(cls: type) -> list[tuple[str, type]]:
+ """Return (field_name, safe_type) pairs for fields typed as a validated safe type."""
+ try:
+ hints = get_type_hints(cls)
+ except Exception:
+ return []
+ return [(name, hint) for name, hint in hints.items() if hint in VALIDATED_TYPES]
+
+
async def run_validators(kwargs: dict[str, Any], validated_params: list[tuple[str, type]]) -> None:
"""Validate URL parameters in order, using the cache/DB validators."""
project_name_param = "project_name"
for param_name, param_type in validated_params:
raw = kwargs[param_name]
if param_type is safe.ProjectName:
- kwargs[param_name] = await validate_project(raw)
- project_name_param = param_name
+ safe_name = await safe.ProjectName.create(raw)
+ if safe_name:
+ kwargs[param_name] = await safe.ProjectName.create(raw)
+ project_name_param = param_name
+ else:
+ raise base.ASFQuartException(f"Project name {param_name!r} is invalid. ")
elif param_type is safe.VersionName:
project_name = kwargs.get(project_name_param, "")
- kwargs[param_name] = await validate_version(project_name, raw)
-
-
-async def validate_project(raw: str) -> safe.ProjectName:
- if cache.project_version_has_project(raw):
- return safe.ProjectName(raw)
- async with db.session() as data:
- project = await data.project(name=raw, status=sql.ProjectStatus.ACTIVE, _committee=False).get()
- if project is None:
- raise base.ASFQuartException(f"Project {raw!r} not found", errorcode=404)
- return safe.ProjectName(project.name)
-
-
-async def validate_version(project_name: safe.ProjectName, raw: str) -> safe.VersionName:
- if cache.project_version_has_version(project_name, raw):
- return safe.VersionName(raw)
- async with db.session() as data:
- release = await data.release(
- project_name=str(project_name),
- version=raw,
- _project=False,
- _committee=False,
- ).get()
- if release is None:
- raise base.ASFQuartException(f"Version {raw!r} not found for project {project_name!s}", errorcode=404)
- return safe.VersionName(release.version)
+ safe_name = await safe.VersionName.create(project_name, raw)
+ if safe_name:
+ kwargs[param_name] = await safe.VersionName.create(project_name, raw)
+ else:
+ raise base.ASFQuartException(f"Version name {param_name!r} is invalid. ")
+
+
+async def validate_safe_fields(
+ instance: Any,
+ safe_params: list[tuple[str, type]],
+ context: dict[str, Any],
+) -> None:
+ """Validate safe-typed fields on a body, query, or form instance via cache/DB lookup.
+
+ Context should contain any URL params already validated, so that validate_version
+ can find a project_name that lives in the URL rather than the instance.
+ """
+ temp = dict(context)
+ for name, _ in safe_params:
+ value = getattr(instance, name, None)
+ if value is not None:
+ temp[name] = str(value)
+ await run_validators(temp, [(n, t) for n, t in safe_params if n in temp])
+ for name, _ in safe_params:
+ if name in temp:
+ setattr(instance, name, temp[name])
def _is_body_type(hint: Any) -> bool:
diff --git a/atr/blueprints/post.py b/atr/blueprints/post.py
index 8224d281..7bd6c842 100644
--- a/atr/blueprints/post.py
+++ b/atr/blueprints/post.py
@@ -66,6 +66,7 @@ def typed(func: Callable[..., Any]) -> web.RouteFunction[Any]:
path, validated_params, literal_params, form_param, public = common.build_path(func)
project_name_var = next((name for name, t in validated_params if t is safe.ProjectName), None)
check_access = not public and (project_name_var is not None)
+ form_safe_params = common.safe_params_for_type(form_param[1]) if form_param is not None else []
async def wrapper(*_args: Any, **kwargs: Any) -> Any:
enhanced_session = await common.authenticate_public() if public else await common.authenticate()
@@ -95,6 +96,8 @@ def typed(func: Callable[..., Any]) -> web.RouteFunction[Any]:
await quart.flash(summary, category="error")
await quart.flash(json.dumps(flash_data), category="form-error-data")
return quart.redirect(quart.request.path)
+ if form_safe_params:
+ await common.validate_safe_fields(kwargs[form_param_name], form_safe_params, kwargs)
start_time_ns = time.perf_counter_ns()
response = await func(enhanced_session, **kwargs)
diff --git a/atr/cache.py b/atr/cache.py
index e578f0aa..0e4ecf62 100644
--- a/atr/cache.py
+++ b/atr/cache.py
@@ -181,7 +181,7 @@ async def _project_version_fetch_from_db() -> dict[str, set[str]]:
all_projects = await data.project(status=sql.ProjectStatus.ACTIVE, _committee=False).all()
for project in all_projects:
all_releases = await data.release(project_name=project.name, _project=False, _committee=False).all()
- projects[project.name] = {release.version for release in all_releases}
+ projects[str(project.name)] = {str(release.version) for release in all_releases}
return projects
diff --git a/atr/construct.py b/atr/construct.py
index f36ba1a6..f4ca7326 100644
--- a/atr/construct.py
+++ b/atr/construct.py
@@ -25,6 +25,7 @@ import quart
import atr.config as config
import atr.db as db
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.paths as paths
import atr.util as util
@@ -53,8 +54,8 @@ TEMPLATE_VARIABLES: list[tuple[str, str, set[Context]]] = [
class AnnounceReleaseOptions:
asfuid: str
fullname: str
- project_name: str
- version_name: str
+ project_name: safe.ProjectName
+ version_name: safe.VersionName
revision_number: str
@@ -62,17 +63,17 @@ class AnnounceReleaseOptions:
class StartVoteOptions:
asfuid: str
fullname: str
- project_name: str
- version_name: str
+ project_name: safe.ProjectName
+ version_name: safe.VersionName
revision_number: str
vote_duration: int
-async def announce_release_default(project_name: str) -> str:
+async def announce_release_default(project_name: safe.ProjectName) -> str:
async with db.session() as data:
- project = await data.project(name=project_name, status=sql.ProjectStatus.ACTIVE, _release_policy=True).demand(
- RuntimeError(f"Project {project_name} not found")
- )
+ project = await data.project(
+ name=str(project_name), status=sql.ProjectStatus.ACTIVE, _release_policy=True
+ ).demand(RuntimeError(f"Project {project_name} not found"))
return project.policy_announce_release_template
@@ -91,8 +92,8 @@ async def announce_release_subject_and_body(
async with db.session() as data:
release = await data.release(
- project_name=options.project_name,
- version=options.version_name,
+ project_name=str(options.project_name),
+ version=str(options.version_name),
_project=True,
_committee=True,
phase=sql.ReleasePhase.RELEASE_PREVIEW,
@@ -105,18 +106,18 @@ async def announce_release_subject_and_body(
revision_number = revision.number if revision else ""
revision_tag = revision.tag if (revision and revision.tag) else ""
- project_display_name = release.project.short_display_name if release.project else options.project_name
+ project_display_name = release.project.short_display_name if release.project else str(options.project_name)
routes_file_selected = get.file.selected
download_path = util.as_url(
- routes_file_selected, project_name=options.project_name, version_name=options.version_name
+ routes_file_selected, project_name=str(options.project_name), version_name=str(options.version_name)
)
# TODO: This download_url should probably be for the proxy download directory, not the ATR view
download_url = f"https://{host}{download_path}"
# Perform substitutions in the subject
subject = subject.replace("{{PROJECT}}", project_display_name)
- subject = subject.replace("{{VERSION}}", options.version_name)
+ subject = subject.replace("{{VERSION}}", str(options.version_name))
# Perform substitutions in the body
body = body.replace("{{COMMITTEE}}", committee.display_name)
@@ -124,18 +125,18 @@ async def announce_release_subject_and_body(
body = body.replace("{{PROJECT}}", project_display_name)
body = body.replace("{{REVISION}}", revision_number)
body = body.replace("{{TAG}}", revision_tag)
- body = body.replace("{{VERSION}}", options.version_name)
+ body = body.replace("{{VERSION}}", str(options.version_name))
body = body.replace("{{YOUR_ASF_ID}}", options.asfuid)
body = body.replace("{{YOUR_FULL_NAME}}", options.fullname)
return subject, body
-async def announce_release_subject_default(project_name: str) -> str:
+async def announce_release_subject_default(project_name: safe.ProjectName) -> str:
async with db.session() as data:
- project = await data.project(name=project_name, status=sql.ProjectStatus.ACTIVE, _release_policy=True).demand(
- RuntimeError(f"Project {project_name} not found")
- )
+ project = await data.project(
+ name=str(project_name), status=sql.ProjectStatus.ACTIVE, _release_policy=True
+ ).demand(RuntimeError(f"Project {project_name} not found"))
return project.policy_announce_release_subject
@@ -151,7 +152,7 @@ def announce_template_variables() -> list[tuple[str, str]]:
def checklist_body(
markdown: str,
project: sql.Project,
- version_name: str,
+ version_name: safe.VersionName,
committee: sql.Committee,
revision: sql.Revision | None,
) -> str:
@@ -172,7 +173,7 @@ def checklist_body(
markdown = markdown.replace("{{REVIEW_URL}}", review_url)
markdown = markdown.replace("{{REVISION}}", revision_number)
markdown = markdown.replace("{{TAG}}", revision_tag)
- markdown = markdown.replace("{{VERSION}}", version_name)
+ markdown = markdown.replace("{{VERSION}}", str(version_name))
return markdown
@@ -180,11 +181,11 @@ def checklist_template_variables() -> list[tuple[str, str]]:
return [(name, desc) for (name, desc, contexts) in TEMPLATE_VARIABLES if "checklist" in contexts]
-async def start_vote_default(project_name: str) -> str:
+async def start_vote_default(project_name: safe.ProjectName) -> str:
async with db.session() as data:
- project = await data.project(name=project_name, status=sql.ProjectStatus.ACTIVE, _release_policy=True).demand(
- RuntimeError(f"Project {project_name} not found")
- )
+ project = await data.project(
+ name=str(project_name), status=sql.ProjectStatus.ACTIVE, _release_policy=True
+ ).demand(RuntimeError(f"Project {project_name} not found"))
return project.policy_start_vote_template
@@ -196,8 +197,8 @@ async def start_vote_subject_and_body(subject: str, body: str, options: StartVot
async with db.session() as data:
# Do not limit by phase, as it may be at RELEASE_CANDIDATE already
release = await data.release(
- project_name=options.project_name,
- version=options.version_name,
+ project_name=str(options.project_name),
+ version=str(options.version_name),
_project=True,
_committee=True,
).demand(RuntimeError(f"Release {options.project_name} {options.version_name} not found"))
@@ -215,12 +216,14 @@ async def start_vote_subject_and_body(subject: str, body: str, options: StartVot
host = config.get().APP_HOST
checklist_path = util.as_url(
- checklist.selected, project_name=options.project_name, version_name=options.version_name
+ checklist.selected, project_name=str(options.project_name), version_name=str(options.version_name)
)
checklist_url = f"https://{host}{checklist_path}"
- review_path = util.as_url(vote.selected, project_name=options.project_name, version_name=options.version_name)
+ review_path = util.as_url(
+ vote.selected, project_name=str(options.project_name), version_name=str(options.version_name)
+ )
review_url = f"https://{host}{review_path}"
- project_display_name = release.project.short_display_name if release.project else options.project_name
+ project_display_name = release.project.short_display_name if release.project else str(options.project_name)
vote_end = datetime.datetime.now(datetime.UTC) + datetime.timedelta(hours=options.vote_duration)
vote_end_str = f"{vote_end.day} {vote_end.strftime('%b %H:%M')} UTC"
@@ -253,10 +256,10 @@ async def start_vote_subject_and_body(subject: str, body: str, options: StartVot
# Perform substitutions in the subject
subject = subject.replace("{{COMMITTEE}}", committee.display_name)
- subject = subject.replace("{{PROJECT}}", project_display_name)
+ subject = subject.replace("{{PROJECT}}", str(project_display_name))
subject = subject.replace("{{REVISION}}", revision_number)
subject = subject.replace("{{TAG}}", revision_tag)
- subject = subject.replace("{{VERSION}}", options.version_name)
+ subject = subject.replace("{{VERSION}}", str(options.version_name))
subject = subject.replace("{{VOTE_ENDS_UTC}}", vote_end_str)
# Perform substitutions in the body
@@ -265,23 +268,23 @@ async def start_vote_subject_and_body(subject: str, body: str, options: StartVot
body = body.replace("{{COMMITTEE}}", committee.display_name)
body = body.replace("{{DURATION}}", str(options.vote_duration))
body = body.replace("{{KEYS_FILE}}", keys_file or "(Sorry, the KEYS file is missing!)")
- body = body.replace("{{PROJECT}}", project_display_name)
+ body = body.replace("{{PROJECT}}", str(project_display_name))
body = body.replace("{{RELEASE_CHECKLIST}}", checklist_content)
body = body.replace("{{REVIEW_URL}}", review_url)
body = body.replace("{{REVISION}}", revision_number)
body = body.replace("{{TAG}}", revision_tag)
- body = body.replace("{{VERSION}}", options.version_name)
+ body = body.replace("{{VERSION}}", str(options.version_name))
body = body.replace("{{YOUR_ASF_ID}}", options.asfuid)
body = body.replace("{{YOUR_FULL_NAME}}", options.fullname)
return subject, body
-async def start_vote_subject_default(project_name: str) -> str:
+async def start_vote_subject_default(project_name: safe.ProjectName) -> str:
async with db.session() as data:
- project = await data.project(name=project_name, status=sql.ProjectStatus.ACTIVE, _release_policy=True).demand(
- RuntimeError(f"Project {project_name} not found")
- )
+ project = await data.project(
+ name=str(project_name), status=sql.ProjectStatus.ACTIVE, _release_policy=True
+ ).demand(RuntimeError(f"Project {project_name} not found"))
return project.policy_start_vote_subject
diff --git a/atr/datasources/apache.py b/atr/datasources/apache.py
index e9547dcb..22b4a7b3 100644
--- a/atr/datasources/apache.py
+++ b/atr/datasources/apache.py
@@ -32,6 +32,7 @@ import atr.db as db
import atr.ldap as ldap
import atr.log as log
import atr.models.helpers as helpers
+import atr.models.safe as safe
import atr.models.schema as schema
import atr.models.sql as sql
import atr.util as util
@@ -194,7 +195,7 @@ class ProjectStatus(schema.Strict):
programming_language: str | None = schema.alias_opt("programming-language")
doap: str | None = None
homepage: str
- name: str
+ name: safe.ProjectName
pmc: str | None
shortdesc: str | None = None
repository: list[str | dict] = schema.factory(list)
@@ -353,7 +354,7 @@ def _project_status(pmc: sql.Committee, project_name: str, project_status: Proje
if pmc.name == "attic":
# This must come first, because attic is also a standing committee
return sql.ProjectStatus.RETIRED
- elif ("_dormant_" in project_name) or project_status.name.endswith("(Dormant)"):
+ elif ("_dormant_" in project_name) or str(project_status.name).endswith("(Dormant)"):
return sql.ProjectStatus.DORMANT
elif util.committee_is_standing(pmc.name):
return sql.ProjectStatus.STANDING
@@ -449,6 +450,7 @@ async def _update_projects(data: db.Session, projects: ProjectsData) -> tuple[in
# the PMC seems to be identified by the key ws, but the associated projects use webservices
if project_name.startswith("webservices-"):
project_name = project_name.replace("webservices-", "ws-")
+ safe_name = safe.ProjectName(project_name)
project_status.pmc = "ws"
# TODO: Annotator is in both projects and ldap_projects
@@ -482,7 +484,7 @@ async def _update_projects(data: db.Session, projects: ProjectsData) -> tuple[in
project_model.status = status
updated_count += 1
- project_model.full_name = project_status.name
+ project_model.full_name = str(project_status.name)
project_model.category = project_status.category
project_model.description = project_status.description
project_model.programming_languages = project_status.programming_language
diff --git a/atr/db/__init__.py b/atr/db/__init__.py
index 6b3e1504..a5514511 100644
--- a/atr/db/__init__.py
+++ b/atr/db/__init__.py
@@ -34,6 +34,7 @@ import sqlmodel.sql.expression as expression
import atr.config as config
import atr.log as log
+import atr.models.safe as safe
import atr.models.schema as schema
import atr.models.sql as sql
import atr.util as util
@@ -864,9 +865,9 @@ def ensure_session(caller_data: Session | None) -> Session | contextlib.nullcont
return contextlib.nullcontext(caller_data)
-async def get_project_release_policy(data: Session, project_name: str) -> sql.ReleasePolicy | None:
+async def get_project_release_policy(data: Session, project_name: safe.ProjectName) -> sql.ReleasePolicy | None:
"""Fetch the ReleasePolicy for a project."""
- project = await data.project(name=project_name, status=sql.ProjectStatus.ACTIVE, _release_policy=True).demand(
+ project = await data.project(name=str(project_name), status=sql.ProjectStatus.ACTIVE, _release_policy=True).demand(
RuntimeError(f"Project {project_name} not found")
)
return project.release_policy
diff --git a/atr/db/interaction.py b/atr/db/interaction.py
index 6e7e17a5..5d8bdd8f 100644
--- a/atr/db/interaction.py
+++ b/atr/db/interaction.py
@@ -32,6 +32,7 @@ import atr.jwtoken as jwtoken
import atr.ldap as ldap
import atr.log as log
import atr.models.results as results
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.user as user
import atr.util as util
@@ -88,7 +89,7 @@ async def all_releases(project: sql.Project) -> list[sql.Release]:
def sort_key(release: sql.Release) -> tuple[tuple[int, int | str], ...]:
parts = []
- v = release.version.replace("+", ".").replace("-", ".")
+ v = str(release.version).replace("+", ".").replace("-", ".")
for part in v.split("."):
try:
# Numeric parts: (0, number) to sort before strings
@@ -170,7 +171,7 @@ async def checks_for(
"""Get the check results for a release, optionally for a specific revision and/or file path."""
if revision is None:
revision = release.unwrap_revision_number
- file_path_checks = await attestable.load_checks(release.project_name, release.version, revision)
+ file_path_checks = await attestable.load_checks(release.safe_project_name, release.safe_version_name, revision)
if file_path_checks:
if rel_path is not None:
hashes = [
@@ -195,7 +196,9 @@ async def checks_for(
async def count_checks_for_revision_by_status(
status: sql.CheckResultStatus, release: sql.Release, revision_number: str, caller_data: db.Session | None = None
):
- file_path_checks = await attestable.load_checks(release.project_name, release.version, revision_number)
+ file_path_checks = await attestable.load_checks(
+ release.safe_project_name, release.safe_version_name, revision_number
+ )
check_hashes = [h for inner in file_path_checks.values() for h in inner.values()]
if len(check_hashes) == 0:
return 0
@@ -239,18 +242,20 @@ async def has_failing_checks(release: sql.Release, revision_number: str, caller_
return count > 0
-async def latest_info(project_name: str, version_name: str) -> tuple[str, str, datetime.datetime] | None:
+async def latest_info(
+ project_name: safe.ProjectName, version_name: safe.VersionName
+) -> tuple[str, str, datetime.datetime] | None:
"""Get the name, editor, and timestamp of the latest revision."""
release_name = sql.release_name(project_name, version_name)
async with db.session() as data:
# TODO: No need to get release here
# Just use maximum seq from revisions
- release = await data.release(name=release_name, _project=True).demand(
+ release = await data.release(name=str(release_name), _project=True).demand(
RuntimeError(f"Release {release_name} does not exist")
)
if release.latest_revision_number is None:
return None
- revision = await data.revision(release_name=release_name, number=release.latest_revision_number).get()
+ revision = await data.revision(release_name=str(release_name), number=release.latest_revision_number).get()
if not revision:
return None
return revision.number, revision.asfuid, revision.created
@@ -291,8 +296,8 @@ async def release_latest_vote_task(release: sql.Release, caller_data: db.Session
async def release_ready_for_vote( # noqa: C901
session: web.Committer,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
revision: str,
data: db.Session,
manual_vote: bool = False,
@@ -391,7 +396,9 @@ def task_recipient_get(latest_vote_task: sql.Task) -> str | None:
return result.email_to
-async def tasks_ongoing(project_name: str, version_name: str, revision_number: str | None = None) -> int:
+async def tasks_ongoing(
+ project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str | None = None
+) -> int:
tasks = sqlmodel.select(sqlalchemy.func.count()).select_from(sql.Task)
async with db.session() as data:
query = tasks.where(
@@ -406,8 +413,8 @@ async def tasks_ongoing(project_name: str, version_name: str, revision_number: s
async def tasks_ongoing_revision(
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
revision_number: str | None = None,
) -> tuple[int, str | None]:
via = sql.validate_instrumented_attribute
@@ -453,17 +460,22 @@ async def trusted_jwt(publisher: str, jwt: str, phase: TrustedProjectPhase) -> t
async def trusted_jwt_for_dist(
- publisher: str, jwt: str, asf_uid: str, phase: TrustedProjectPhase, project_name: str, version_name: str
+ publisher: str,
+ jwt: str,
+ asf_uid: str,
+ phase: TrustedProjectPhase,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
) -> tuple[dict[str, Any], str, sql.Project, sql.Release]:
payload, asf_uid_from_jwt = await validate_trusted_jwt(publisher, jwt)
if asf_uid_from_jwt is not None:
raise InteractionError("Must use Trusted Publishing when specifying ASF UID")
# payload, asf_uid, project = await trusted_jwt(publisher, jwt, phase)
async with db.session() as db_data:
- project = await db_data.project(name=project_name, _committee=True).demand(
+ project = await db_data.project(name=str(project_name), _committee=True).demand(
InteractionError(f"Project {project_name} does not exist")
)
- release = await db_data.release(project_name=project_name, version=version_name).get()
+ release = await db_data.release(project_name=str(project_name), version=str(version_name)).get()
if not release:
raise InteractionError(f"Release {version_name} does not exist in project {project_name}")
if (phase == TrustedProjectPhase.COMPOSE) and (release.phase != sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT):
@@ -476,8 +488,8 @@ async def trusted_jwt_for_dist(
return payload, asf_uid, project, release
-async def unfinished_releases(asfuid: str) -> list[tuple[str, str, list[sql.Release]]]:
- releases: list[tuple[str, str, list[sql.Release]]] = []
+async def unfinished_releases(asfuid: str) -> list[tuple[str, safe.ProjectName, list[sql.Release]]]:
+ releases: list[tuple[str, safe.ProjectName, list[sql.Release]]] = []
async with db.session() as data:
user_projects = await user.projects(asfuid)
user_projects.sort(key=lambda p: p.display_name)
@@ -501,7 +513,7 @@ async def unfinished_releases(asfuid: str) -> list[tuple[str, str, list[sql.Rele
active_releases = list(result.scalars().all())
if active_releases:
active_releases.sort(key=lambda r: r.created, reverse=True)
- releases.append((project.short_display_name, project.name, active_releases))
+ releases.append((project.short_display_name, project.safe_name, active_releases))
return releases
@@ -531,9 +543,9 @@ async def user_committees_participant(asf_uid: str, caller_data: db.Session | No
return await data.committee(has_participant=asf_uid).all()
-async def user_projects(asf_uid: str, caller_data: db.Session | None = None) -> list[tuple[str, str]]:
+async def user_projects(asf_uid: str, caller_data: db.Session | None = None) -> list[tuple[safe.ProjectName, str]]:
projects = await user.projects(asf_uid)
- return [(p.name, p.display_name) for p in projects]
+ return [(p.safe_name, p.display_name) for p in projects]
async def validate_trusted_jwt(publisher: str, jwt: str) -> tuple[dict[str, Any], str | None]:
diff --git a/atr/get/announce.py b/atr/get/announce.py
index 29c0cfed..663cfa9e 100644
--- a/atr/get/announce.py
+++ b/atr/get/announce.py
@@ -59,16 +59,16 @@ async def selected(
)
# Get the templates from the release policy
- default_subject_template = await construct.announce_release_subject_default(str(project_name))
- default_body_template = await construct.announce_release_default(str(project_name))
+ default_subject_template = await construct.announce_release_subject_default(project_name)
+ default_body_template = await construct.announce_release_default(project_name)
subject_template_hash = construct.template_hash(default_subject_template)
# Expand the templates
options = construct.AnnounceReleaseOptions(
asfuid=session.uid,
fullname=session.fullname,
- project_name=str(project_name),
- version_name=str(version_name),
+ project_name=project_name,
+ version_name=version_name,
revision_number=latest_revision_number,
)
default_subject, default_body = await construct.announce_release_subject_and_body(
@@ -114,8 +114,8 @@ async def _get_page_data(
session: web.Committer, project_name: safe.ProjectName, version_name: safe.VersionName
) -> sql.Release:
release = await session.release(
- str(project_name),
- str(version_name),
+ project_name,
+ version_name,
with_committee=True,
phase=sql.ReleasePhase.RELEASE_PREVIEW,
with_distributions=True,
@@ -220,13 +220,13 @@ async def _render_page(
"""
page.style[markupsafe.Markup(page_styles)]
- render.html_nav_phase(page, release.project.name, release.version, staging=False)
+ render.html_nav_phase(page, str(release.project.name), str(release.version), staging=False)
page.h1[
"Announce ",
htm.strong[release.project.short_display_name],
" ",
- htm.em[release.version],
+ htm.em[str(release.version)],
]
page.append(_render_release_card(release))
page.h2["Announce this release"]
@@ -248,8 +248,8 @@ async def _render_page(
if not announce_msg:
page.p[f"This form will send an announcement to the ASF {util.USER_TESTS_ADDRESS} mailing list."]
- custom_subject_widget = _render_subject_field(default_subject, release.project.name)
- custom_body_widget = _render_body_field(default_body, release.project.name)
+ custom_subject_widget = _render_subject_field(default_subject, str(release.project.name))
+ custom_body_widget = _render_body_field(default_body, str(release.project.name))
custom_mailing_list_widget = _render_mailing_list_with_warning(mailing_list_choices, util.USER_TESTS_ADDRESS)
# Custom widget for download_path_suffix with custom documentation
diff --git a/atr/get/checklist.py b/atr/get/checklist.py
index 2d4fd788..d5ba2e3c 100644
--- a/atr/get/checklist.py
+++ b/atr/get/checklist.py
@@ -67,7 +67,7 @@ async def selected(
substituted_markdown = construct.checklist_body(
checklist_markdown,
project=project,
- version_name=str(version_name),
+ version_name=version_name,
committee=committee,
revision=latest_revision,
)
diff --git a/atr/get/checks.py b/atr/get/checks.py
index df41705c..80bdde58 100644
--- a/atr/get/checks.py
+++ b/atr/get/checks.py
@@ -92,7 +92,7 @@ async def get_file_totals(release: sql.Release, session: web.Committer | None) -
async with storage.read(session) as read:
ragp = read.as_general_public()
- match_ignore = await ragp.checks.ignores_matcher(release.project_name)
+ match_ignore = await ragp.checks.ignores_matcher(release.safe_project_name)
_, totals = await _compute_stats(release, all_paths, match_ignore)
return totals
@@ -123,7 +123,7 @@ async def selected(
async with storage.read(session) as read:
ragp = read.as_general_public()
- match_ignore = await ragp.checks.ignores_matcher(release.project_name)
+ match_ignore = await ragp.checks.ignores_matcher(release.safe_project_name)
per_file_stats, totals = await _compute_stats(release, all_paths, match_ignore)
@@ -169,9 +169,9 @@ async def selected_revision(
ragp = read.as_general_public()
info = await ragp.releases.path_info(release, all_paths)
- ongoing_count = await interaction.tasks_ongoing(str(project_name), str(version_name), revision_number)
+ ongoing_count = await interaction.tasks_ongoing(project_name, version_name, revision_number)
- checks_summary_elem = shared.web.render_checks_summary(info, str(project_name), str(version_name))
+ checks_summary_elem = shared.web.render_checks_summary(info, project_name, version_name)
checks_summary_html = str(checks_summary_elem) if checks_summary_elem else ""
delete_file_forms: dict[str, str] = {}
@@ -506,7 +506,7 @@ def _render_file_row(
def _render_header(page: htm.Block, release: sql.Release) -> None:
render.html_nav(
page,
- back_url=util.as_url(vote.selected, project_name=release.project.name, version_name=release.version),
+ back_url=util.as_url(vote.selected, project_name=str(release.project.name), version_name=str(release.version)),
back_anchor=f"Vote on {release.project.short_display_name} {release.version}",
phase="VOTE",
)
@@ -515,7 +515,7 @@ def _render_header(page: htm.Block, release: sql.Release) -> None:
"File checks for ",
htm.strong[release.project.short_display_name],
" ",
- htm.em[release.version],
+ htm.em[str(release.version)],
]
@@ -526,7 +526,7 @@ def _render_ignores_section(page: htm.Block, release: sql.Release) -> None:
"Project committee members can configure rules to ignore specific check results. "
"Ignored checks are excluded from the counts shown above.",
]
- ignores_url = util.as_url(ignores.ignores, project_name=release.project.name)
+ ignores_url = util.as_url(ignores.ignores, project_name=str(release.project.name))
page.div[htpy.a(".btn.btn-outline-primary", href=ignores_url)["Manage check ignores"],]
diff --git a/atr/get/distribution.py b/atr/get/distribution.py
index e5955e11..efcedfe8 100644
--- a/atr/get/distribution.py
+++ b/atr/get/distribution.py
@@ -46,7 +46,7 @@ async def automate(
URL: /distribution/automate/<project_name>/<version>
"""
await session.check_access(project_name)
- return await _automate_form_page(str(project_name), str(version_name), staging=False)
+ return await _automate_form_page(project_name, version_name, staging=False)
@get.typed
@@ -59,11 +59,11 @@ async def list_get(
"""
URL: /distribution/list/<project_name>/<version_name>
"""
- distributions, tasks = await _get_page_data(str(project_name), str(version_name))
+ distributions, tasks = await _get_page_data(project_name, version_name)
block = htm.Block()
- release = await shared.distribution.release_validated(str(project_name), str(version_name), staging=None)
+ release = await shared.distribution.release_validated(project_name, version_name, staging=None)
staging = release.phase == sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
render.html_nav_phase(block, str(project_name), str(version_name), staging)
@@ -80,7 +80,7 @@ async def list_get(
block.h1["Distribution list for ", htm.em[f"{project_name!s}-{version_name!s}"]]
if len(tasks) > 0:
- _render_distribution_tasks(tasks, block, str(project_name), str(version_name))
+ _render_distribution_tasks(tasks, block, project_name, version_name)
if not distributions:
block.p["No distributions found."]
@@ -107,7 +107,7 @@ async def list_get(
id=f"distribution-{dist.identifier}"
)[dist.title, *title_extra]
tbody = htm.tbody[
- shared.distribution.html_tr("Release name", dist.release_name),
+ shared.distribution.html_tr("Release name", str(dist.release_name)),
shared.distribution.html_tr("Platform", dist.platform.value.name),
shared.distribution.html_tr("Owner or Namespace", dist.owner_namespace or "-"),
shared.distribution.html_tr("Package", dist.package),
@@ -154,7 +154,7 @@ async def record(
URL: /distribution/record/<project_name>/<version_name>
"""
await session.check_access(project_name)
- return await _record_form_page(str(project_name), str(version_name), staging=False)
+ return await _record_form_page(project_name, version_name, staging=False)
@get.typed
@@ -168,7 +168,7 @@ async def stage_automate(
URL: /distribution/stage/automate/<project_name>/<version_name>
"""
await session.check_access(project_name)
- return await _automate_form_page(str(project_name), str(version_name), staging=True)
+ return await _automate_form_page(project_name, version_name, staging=True)
@get.typed
@@ -182,15 +182,15 @@ async def stage_record(
URL: /distribution/stage/record/<project_name>/<version_name>
"""
await session.check_access(project_name)
- return await _record_form_page(str(project_name), str(version_name), staging=True)
+ return await _record_form_page(project_name, version_name, staging=True)
-async def _automate_form_page(project: str, version: str, staging: bool) -> str:
+async def _automate_form_page(project: safe.ProjectName, version: safe.VersionName, staging: bool) -> str:
"""Helper to render the distribution automation form page."""
await shared.distribution.release_validated(project, version, staging=staging)
block = htm.Block()
- render.html_nav_phase(block, project, version, staging=staging)
+ render.html_nav_phase(block, str(project), str(version), staging=staging)
title = "Create a staging distribution" if staging else "Create a distribution"
block.h1[title]
@@ -202,15 +202,17 @@ async def _automate_form_page(project: str, version: str, staging: bool) -> str:
]
block.p[
"You can also ",
- htm.a(href=util.as_url(list_get, project_name=project, version_name=version))["view the distribution list"],
+ htm.a(href=util.as_url(list_get, project_name=str(project), version_name=str(version)))[
+ "view the distribution list"
+ ],
".",
]
# Determine the action based on staging
action = (
- util.as_url(post.distribution.stage_automate_selected, project_name=project, version_name=version)
+ util.as_url(post.distribution.stage_automate_selected, project_name=str(project), version_name=str(version))
if staging
- else util.as_url(post.distribution.automate_selected, project_name=project, version_name=version)
+ else util.as_url(post.distribution.automate_selected, project_name=str(project), version_name=str(version))
)
# TODO: Reuse the same form for now - maybe we can combine this and the function below adding an automate=True arg
@@ -219,31 +221,33 @@ async def _automate_form_page(project: str, version: str, staging: bool) -> str:
model_cls=shared.distribution.DistributeForm,
submit_label="Distribute",
action=action,
- defaults={"package": project, "version": version},
+ defaults={"package": str(project), "version": str(version)},
)
block.append(form_html)
return await template.blank(title, content=block.collect())
-async def _get_page_data(project_name: str, version_name: str) -> tuple[Sequence[sql.Distribution], Sequence[sql.Task]]:
+async def _get_page_data(
+ project_name: safe.ProjectName, version_name: safe.VersionName
+) -> tuple[Sequence[sql.Distribution], Sequence[sql.Task]]:
"""Get all the data needed to render the finish page."""
async with db.session() as data:
via = sql.validate_instrumented_attribute
distributions = await data.distribution(
- release_name=sql.release_name(project_name, version_name),
+ release_name=sql.release_name(str(project_name), str(version_name)),
).all()
release = await data.release(
- project_name=project_name,
- version=version_name,
+ project_name=str(project_name),
+ version=str(version_name),
_committee=True,
).demand(base.ASFQuartException("Release does not exist", errorcode=404))
tasks = [
t
for t in (
await data.task(
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
revision_number=release.latest_revision_number,
task_type=sql.TaskType.DISTRIBUTION_WORKFLOW,
_workflow=True,
@@ -258,12 +262,12 @@ async def _get_page_data(project_name: str, version_name: str) -> tuple[Sequence
return distributions, tasks
-async def _record_form_page(project: str, version: str, staging: bool) -> str:
+async def _record_form_page(project: safe.ProjectName, version: safe.VersionName, staging: bool) -> str:
"""Helper to render the distribution recording form page."""
await shared.distribution.release_validated(project, version, staging=staging)
block = htm.Block()
- render.html_nav_phase(block, project, version, staging=staging)
+ render.html_nav_phase(block, str(project), str(version), staging=staging)
title = "Record a manual staging distribution" if staging else "Record a manual distribution"
block.h1[title]
@@ -275,15 +279,17 @@ async def _record_form_page(project: str, version: str, staging: bool) -> str:
]
block.p[
"You can also ",
- htm.a(href=util.as_url(list_get, project_name=project, version_name=version))["view the distribution list"],
+ htm.a(href=util.as_url(list_get, project_name=str(project), version_name=str(version)))[
+ "view the distribution list"
+ ],
".",
]
# Determine the action based on staging
action = (
- util.as_url(post.distribution.stage_record_selected, project_name=project, version_name=version)
+ util.as_url(post.distribution.stage_record_selected, project_name=str(project), version_name=str(version))
if staging
- else util.as_url(post.distribution.record_selected, project_name=project, version_name=version)
+ else util.as_url(post.distribution.record_selected, project_name=str(project), version_name=str(version))
)
# Render the distribution form
@@ -291,14 +297,16 @@ async def _record_form_page(project: str, version: str, staging: bool) -> str:
model_cls=shared.distribution.DistributeForm,
submit_label="Record distribution",
action=action,
- defaults={"package": project, "version": version},
+ defaults={"package": str(project), "version": str(version)},
)
block.append(form_html)
return await template.blank(title, content=block.collect())
-def _render_distribution_tasks(tasks: Sequence[sql.Task], block: htm.Block, project_name: str, version_name: str):
+def _render_distribution_tasks(
+ tasks: Sequence[sql.Task], block: htm.Block, project_name: safe.ProjectName, version_name: safe.VersionName
+):
failed_tasks = [
t for t in tasks if (t.status == sql.TaskStatus.FAILED) or (t.workflow and (t.workflow.status == "failed"))
]
@@ -329,8 +337,8 @@ def _render_distribution_tasks(tasks: Sequence[sql.Task], block: htm.Block, proj
".btn.btn-success.mt-2",
href=util.as_url(
list_get,
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
),
)["Refresh"],
]
diff --git a/atr/get/download.py b/atr/get/download.py
index 830f9633..1645e978 100644
--- a/atr/get/download.py
+++ b/atr/get/download.py
@@ -54,9 +54,7 @@ async def all_selected(
import atr.get.root as root
async with db.session() as data:
- release = await session.release(
- project_name=str(project_name), version_name=str(version_name), phase=None, data=data
- )
+ release = await session.release(project_name=project_name, version_name=version_name, phase=None, data=data)
if not release:
return await session.redirect(root.index, error="Release not found")
user_ssh_keys = await data.ssh_key(asf_uid=session.uid).all()
@@ -89,7 +87,7 @@ async def path(
URL: /download/path/<project_name>/<version_name>/<path:file_path>
Download a file or list a directory from a release in any phase.
"""
- return await _download_or_list(str(project_name), str(version_name), str(file_path))
+ return await _download_or_list(project_name, version_name, str(file_path))
@get.typed
@@ -103,7 +101,7 @@ async def path_empty(
URL: /download/path/<project_name>/<version_name>/
List files at the root of a release directory for download.
"""
- return await _download_or_list(str(project_name), str(version_name), ".")
+ return await _download_or_list(project_name, version_name, ".")
@get.typed
@@ -165,7 +163,7 @@ async def zip_selected(
URL: /download/zip/<project_name>/<version_name>
"""
try:
- release = await session.release(project_name=str(project_name), version_name=str(version_name), phase=None)
+ release = await session.release(project_name=project_name, version_name=version_name, phase=None)
except ValueError as e:
return web.TextResponse(f"Error: {e}", status=404)
except Exception as e:
@@ -187,13 +185,15 @@ async def zip_selected(
yield chunk
headers = {
- "Content-Disposition": web.HeaderValue("attachment", filename=release.name + ".zip"),
+ "Content-Disposition": web.HeaderValue("attachment", filename=str(release.name) + ".zip"),
"Content-Type": web.HeaderValue("application/zip"),
}
return web.ZipResponse(stream_zip(files_to_zip), headers=headers)
-async def _download_or_list(project_name: str, version_name: str, file_path: str) -> web.Response:
+async def _download_or_list(
+ project_name: safe.ProjectName, version_name: safe.VersionName, file_path: str
+) -> web.Response:
"""Download a file or list a directory from a release in any phase."""
import atr.get.root as root
@@ -207,13 +207,13 @@ async def _download_or_list(project_name: str, version_name: str, file_path: str
# We allow downloading files from any phase
async with db.session() as data:
- release = await data.release(project_name=project_name, version=version_name).demand(
+ release = await data.release(project_name=str(project_name), version=str(version_name)).demand(
base.ASFQuartException("Release does not exist", errorcode=404)
)
full_path = paths.release_directory(release) / validated_path
if await aiofiles.os.path.isdir(full_path):
- return await _list(validated_path, full_path, project_name, version_name, str(validated_path))
+ return await _list(validated_path, full_path, str(project_name), str(version_name), str(validated_path))
# Check that the path is a regular file
if not await aiofiles.os.path.isfile(full_path):
diff --git a/atr/get/draft.py b/atr/get/draft.py
index c5a2155e..64a5a94a 100644
--- a/atr/get/draft.py
+++ b/atr/get/draft.py
@@ -52,7 +52,7 @@ async def tools(
if validated_path is None:
raise base.ASFQuartException("Invalid file path", errorcode=400)
- release = await session.release(str(project_name), str(version_name))
+ release = await session.release(project_name, version_name)
full_path = str(paths.release_directory(release) / validated_path)
# Check that the file exists
diff --git a/atr/get/file.py b/atr/get/file.py
index c0f3f9c4..2ccb28e2 100644
--- a/atr/get/file.py
+++ b/atr/get/file.py
@@ -46,7 +46,7 @@ async def selected(
URL: /file/<project_name>/<version_name>
View all the files in a release (any phase).
"""
- release = await session.release(str(project_name), str(version_name), phase=None)
+ release = await session.release(project_name, version_name, phase=None)
revision_number = release.latest_revision_number
file_stats = []
@@ -72,7 +72,7 @@ async def selected(
back_url, back_label, phase_label = nav_info
render.html_nav(block, back_url, back_label, phase_label)
- block.h1["Files in ", htm.strong[release.project.short_display_name], " ", htm.em[release.version]]
+ block.h1["Files in ", htm.strong[release.project.short_display_name], " ", htm.em[str(release.version)]]
block.div(".card.mb-4")[
htm.div(".card-header.d-flex.justify-content-between.align-items-center")[
@@ -82,7 +82,7 @@ async def selected(
htm.div(".row")[
htm.div(".col-md-6")[
htm.p[htm.strong["Project:"], " ", release.project.display_name],
- htm.p[htm.strong["Label:"], " ", release.name],
+ htm.p[htm.strong["Label:"], " ", str(release.name)],
],
htm.div(".col-md-6")[htm.p[htm.strong["Created:"], " ", release.created.strftime("%Y-%m-%d %H:%M:%S")]],
]
@@ -98,8 +98,8 @@ async def selected(
if stat.is_file:
file_url = util.as_url(
selected_path,
- project_name=release.project.name,
- version_name=release.version,
+ project_name=str(release.project.name),
+ version_name=str(release.version),
file_path=stat.path,
)
file_link = htm.a(href=file_url)[stat.path]
@@ -153,7 +153,7 @@ async def selected_path(
if validated_path is None:
raise web.FlashError("Invalid file path")
- release = await session.release(str(project_name), str(version_name), phase=None)
+ release = await session.release(project_name, version_name, phase=None)
_max_view_size = 512 * 1024
full_path = paths.release_directory(release) / validated_path
content_listing = await util.archive_listing(full_path)
@@ -161,13 +161,13 @@ async def selected_path(
block = htm.Block()
- back_url = util.as_url(selected, project_name=release.project.name, version_name=release.version)
+ back_url = util.as_url(selected, project_name=str(release.project.name), version_name=str(release.version))
phase_name = _phase_display_name(release.phase)
block.a(href=back_url, class_="atr-back-link")[f"← Back to {phase_name} files"]
block.div(".p-3.mt-4.mb-4.bg-light.border.rounded")[
htm.h2(".mt-0")[f"Viewing file: {validated_path}"],
- htm.p(".mb-0")[htm.strong["Release:"], " ", release.name],
+ htm.p(".mb-0")[htm.strong["Release:"], " ", str(release.name)],
]
if content_listing:
@@ -199,19 +199,19 @@ def _get_navigation_info(release: sql.Release) -> tuple[str, str, Phase] | None:
"""Get back URL, back label, and phase label based on release phase."""
if release.phase == sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT:
return (
- util.as_url(compose.selected, project_name=release.project.name, version_name=release.version),
+ util.as_url(compose.selected, project_name=str(release.project.name), version_name=str(release.version)),
f"Compose {release.short_display_name}",
"COMPOSE",
)
elif release.phase == sql.ReleasePhase.RELEASE_CANDIDATE:
return (
- util.as_url(vote.selected, project_name=release.project.name, version_name=release.version),
+ util.as_url(vote.selected, project_name=str(release.project.name), version_name=str(release.version)),
f"Vote on {release.short_display_name}",
"VOTE",
)
elif release.phase == sql.ReleasePhase.RELEASE_PREVIEW:
return (
- util.as_url(finish.selected, project_name=release.project.name, version_name=release.version),
+ util.as_url(finish.selected, project_name=str(release.project.name), version_name=str(release.version)),
f"Finish {release.short_display_name}",
"FINISH",
)
diff --git a/atr/get/finish.py b/atr/get/finish.py
index f8b558a6..9789711c 100644
--- a/atr/get/finish.py
+++ b/atr/get/finish.py
@@ -72,7 +72,7 @@ async def selected(
await session.check_access(project_name)
try:
(release, source_files_rel, target_dirs, deletable_dirs, rc_analysis, tasks) = await _get_page_data(
- str(project_name), str(version_name)
+ project_name, version_name
)
except ValueError:
async with db.session() as data:
@@ -155,7 +155,7 @@ async def _deletable_choices(
async def _get_page_data(
- project_name: str, version_name: str
+ project_name: safe.ProjectName, version_name: safe.VersionName
) -> tuple[
sql.Release, list[pathlib.Path], set[pathlib.Path], list[tuple[str, str]], RCTagAnalysisResult, Sequence[sql.Task]
]:
@@ -163,8 +163,8 @@ async def _get_page_data(
async with db.session() as data:
via = sql.validate_instrumented_attribute
release = await data.release(
- project_name=project_name,
- version=version_name,
+ project_name=str(project_name),
+ version=str(version_name),
_committee=True,
_release_policy=True,
_project_release_policy=True,
@@ -174,8 +174,8 @@ async def _get_page_data(
t
for t in (
await data.task(
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
revision_number=release.latest_revision_number,
task_type=sql.TaskType.DISTRIBUTION_WORKFLOW,
_workflow=True,
@@ -233,16 +233,16 @@ def _render_distribution_buttons(release: sql.Release) -> htm.Element:
".btn.btn-primary.me-2",
href=util.as_url(
distribution.automate,
- project_name=release.project.name,
- version_name=release.version,
+ project_name=str(release.project.name),
+ version_name=str(release.version),
),
)["Distribute"],
htm.a(
".btn.btn-secondary.me-2",
href=util.as_url(
distribution.record,
- project_name=release.project.name,
- version_name=release.version,
+ project_name=str(release.project.name),
+ version_name=str(release.version),
),
)["Record a manual distribution"],
],
@@ -284,8 +284,8 @@ def _render_distribution_tasks(release: sql.Release, tasks: Sequence[sql.Task])
".btn.btn-success.mt-2",
href=util.as_url(
selected,
- project_name=release.project.name,
- version_name=release.version,
+ project_name=str(release.project.name),
+ version_name=str(release.version),
),
)["Refresh"],
]
@@ -386,7 +386,7 @@ async def _render_page(
"Finish ",
htm.strong[release.project.short_display_name],
" ",
- htm.em[release.version],
+ htm.em[str(release.version)],
]
# Release info card
@@ -511,7 +511,7 @@ def _render_release_card(release: sql.Release, announce_disable_message: str) ->
announce_classes = ".btn-success"
if announce_disable_message:
announce_classes += ".disabled"
- card = htm.div(".card.mb-4.shadow-sm", id=release.name)[
+ card = htm.div(".card.mb-4.shadow-sm", id=str(release.name))[
htm.div(".card-header.bg-light")[htm.h3(".card-title.mb-0")["About this release preview"]],
htm.div(".card-body")[
htm.div(".d-flex.flex-wrap.gap-3.pb-3.mb-3.border-bottom.text-secondary.fs-6")[
@@ -524,8 +524,8 @@ def _render_release_card(release: sql.Release, announce_disable_message: str) ->
title="Download all files",
href=util.as_url(
download.all_selected,
- project_name=release.project.name,
- version_name=release.version,
+ project_name=str(release.project.name),
+ version_name=str(release.version),
),
)[
htm.icon("download"),
@@ -536,8 +536,8 @@ def _render_release_card(release: sql.Release, announce_disable_message: str) ->
title=f"Show files for {release.name}",
href=util.as_url(
file.selected,
- project_name=release.project.name,
- version_name=release.version,
+ project_name=str(release.project.name),
+ version_name=str(release.version),
),
)[
htm.icon("archive"),
@@ -548,8 +548,8 @@ def _render_release_card(release: sql.Release, announce_disable_message: str) ->
title=f"Show revisions for {release.name}",
href=util.as_url(
revisions.selected,
- project_name=release.project.name,
- version_name=release.version,
+ project_name=str(release.project.name),
+ version_name=str(release.version),
),
)[
htm.icon("clock-history"),
@@ -560,8 +560,8 @@ def _render_release_card(release: sql.Release, announce_disable_message: str) ->
title=f"Announce and distribute {release.name}",
href=util.as_url(
announce.selected,
- project_name=release.project.name,
- version_name=release.version,
+ project_name=str(release.project.name),
+ version_name=str(release.version),
)
if (not announce_disable_message)
else None,
diff --git a/atr/get/ignores.py b/atr/get/ignores.py
index bb24979e..fd07bd53 100644
--- a/atr/get/ignores.py
+++ b/atr/get/ignores.py
@@ -42,7 +42,7 @@ async def ignores(
await session.check_access(project_name)
async with storage.read() as read:
ragp = read.as_general_public()
- ignores = await ragp.checks.ignores(str(project_name))
+ ignores = await ragp.checks.ignores(project_name)
content = htm.div[
htm.h1["Ignored checks"],
diff --git a/atr/get/manual.py b/atr/get/manual.py
index 0f774ae1..7d90f0e9 100644
--- a/atr/get/manual.py
+++ b/atr/get/manual.py
@@ -47,8 +47,8 @@ async def resolve_selected(
"""
await session.check_access(project_name)
release = await session.release(
- str(project_name),
- str(version_name),
+ project_name,
+ version_name,
phase=sql.ReleasePhase.RELEASE_CANDIDATE,
with_release_policy=True,
with_project_release_policy=True,
@@ -79,7 +79,7 @@ async def start_selected_revision(
await session.check_access(project_name)
async with db.session() as data:
match await interaction.release_ready_for_vote(
- session, str(project_name), str(version_name), revision, data, manual_vote=True
+ session, project_name, version_name, revision, data, manual_vote=True
):
case str() as error:
return await session.redirect(
diff --git a/atr/get/projects.py b/atr/get/projects.py
index 5e30b96b..ec992b13 100644
--- a/atr/get/projects.py
+++ b/atr/get/projects.py
@@ -104,14 +104,14 @@ async def projects(_session: web.Public, _projects: Literal["projects"]) -> str:
delete_forms: dict[str, htm.Element] = {}
for project in projects:
- delete_forms[project.name] = form.render(
+ delete_forms[str(project.name)] = form.render(
model_cls=shared.projects.DeleteSelectedProject,
action=util.as_url(post.projects.delete),
form_classes=".d-inline-block.m-0",
submit_classes="btn-sm btn-outline-danger",
submit_label="Delete project",
empty=True,
- defaults={"project_name": project.name},
+ defaults={"project_name": str(project.name)},
confirm="Are you sure you want to delete this project? This cannot be undone.",
)
@@ -188,7 +188,7 @@ async def view(
page.append(title_row)
page.p(".mb-4")[
- htm.a(".btn.btn-sm.btn-outline-primary", href=util.as_url(start.selected, project_name=project.name))[
+ htm.a(".btn.btn-sm.btn-outline-primary", href=util.as_url(start.selected, project_name=str(project.name)))[
"Start a new release"
]
]
@@ -297,9 +297,9 @@ def _render_categories_section(project: sql.Project) -> htm.Element:
for cat in current_categories:
remove_button = (
# Manual form as badges are not handled by the form system
- htm.form(".d-inline.m-0", method="post", action=util.as_url(post.projects.view, name=project.name))[
+ htm.form(".d-inline.m-0", method="post", action=util.as_url(post.projects.view, name=str(project.name)))[
form.csrf_input(),
- htpy.input(type="hidden", name="project_name", value=project.name),
+ htpy.input(type="hidden", name="project_name", value=str(project.name)),
htpy.input(type="hidden", name="variant", value="remove_category"),
htpy.input(type="hidden", name="category_to_remove", value=cat),
htpy.button(
@@ -315,9 +315,9 @@ def _render_categories_section(project: sql.Project) -> htm.Element:
]
category_badges.append(badge)
- add_form = htm.form(".mb-3", method="post", action=util.as_url(post.projects.view, name=project.name))[
+ add_form = htm.form(".mb-3", method="post", action=util.as_url(post.projects.view, name=str(project.name)))[
form.csrf_input(),
- htpy.input(type="hidden", name="project_name", value=project.name),
+ htpy.input(type="hidden", name="project_name", value=str(project.name)),
htpy.input(type="hidden", name="variant", value="add_category"),
htm.div(".d-flex.align-items-center")[
htpy.input(
@@ -349,10 +349,10 @@ def _render_compose_form(project: sql.Project) -> htm.Element:
form.render_block(
card_body,
model_cls=shared.projects.ComposePolicyForm,
- action=util.as_url(post.projects.view, name=project.name),
+ action=util.as_url(post.projects.view, name=str(project.name)),
submit_label="Save",
defaults={
- "project_name": project.name,
+ "project_name": str(project.name),
"source_artifact_paths": "\n".join(project.policy_source_artifact_paths),
"license_check_mode": project.policy_license_check_mode,
"source_excludes_lightweight": "\n".join(project.policy_source_excludes_lightweight),
@@ -378,11 +378,11 @@ def _render_delete_section(project: sql.Project) -> htm.Element:
delete_form = form.render(
shared.projects.DeleteProjectForm,
- action=util.as_url(post.projects.view, name=project.name),
+ action=util.as_url(post.projects.view, name=str(project.name)),
form_classes="",
submit_classes="btn-sm btn-outline-danger",
submit_label="Delete project",
- defaults={"project_name": project.name},
+ defaults={"project_name": str(project.name)},
confirm="Are you sure you want to delete this project? This cannot be undone.",
empty=True,
)
@@ -423,7 +423,7 @@ def _render_finish_form(project: sql.Project) -> htm.Element:
form.render_block(
card_body,
model_cls=shared.projects.FinishPolicyForm,
- action=util.as_url(post.projects.view, name=project.name),
+ action=util.as_url(post.projects.view, name=str(project.name)),
submit_label="Save",
defaults={
"project_name": project.name,
@@ -453,10 +453,10 @@ def _render_languages_section(project: sql.Project) -> htm.Element:
for lang in current_languages:
# Manual form as badges are not handled by the form system
remove_button = htm.form(
- ".d-inline.m-0", method="post", action=util.as_url(post.projects.view, name=project.name)
+ ".d-inline.m-0", method="post", action=util.as_url(post.projects.view, name=str(project.name))
)[
form.csrf_input(),
- htpy.input(type="hidden", name="project_name", value=project.name),
+ htpy.input(type="hidden", name="project_name", value=str(project.name)),
htpy.input(type="hidden", name="variant", value="remove_language"),
htpy.input(type="hidden", name="language_to_remove", value=lang),
htpy.button(".btn-close.btn-close-white.ms-1.page-remove-tag", type="submit", aria_label=f"Remove {lang}"),
@@ -467,9 +467,9 @@ def _render_languages_section(project: sql.Project) -> htm.Element:
]
language_badges.append(badge)
- add_form = htm.form(".mb-3", method="post", action=util.as_url(post.projects.view, name=project.name))[
+ add_form = htm.form(".mb-3", method="post", action=util.as_url(post.projects.view, name=str(project.name)))[
form.csrf_input(),
- htpy.input(type="hidden", name="project_name", value=project.name),
+ htpy.input(type="hidden", name="project_name", value=str(project.name)),
htpy.input(type="hidden", name="variant", value="add_language"),
htm.div(".d-flex.align-items-center")[
htpy.input(
@@ -531,7 +531,7 @@ def _render_policy_readonly(project: sql.Project) -> htm.Element:
def _render_project_label_card(project: sql.Project) -> htm.Element:
card = htm.Block(htm.div, classes=".card.mb-4")
card.div(".card-header.bg-light")[htm.h3(".mb-2")["Project label"]]
- card.div(".card-body")[htm.code(".fs-6")[project.name]]
+ card.div(".card-body")[htm.code(".fs-6")[str(project.name)]]
return card.collect()
@@ -552,7 +552,7 @@ async def _render_releases_sections(
draft_buttons.append(
htm.a(
".btn.btn-sm.btn-outline-secondary.py-2.px-3",
- href=util.as_url(file.selected, project_name=project.name, version_name=drf.version),
+ href=util.as_url(file.selected, project_name=str(project.name), version_name=str(drf.version)),
title=f"View draft {project.name} {drf.version}",
)[
f"{project.name} {drf.version} ",
@@ -569,7 +569,7 @@ async def _render_releases_sections(
candidate_buttons.append(
htm.a(
".btn.btn-sm.btn-outline-info.py-2.px-3",
- href=util.as_url(file.selected, project_name=project.name, version_name=cnd.version),
+ href=util.as_url(file.selected, project_name=str(project.name), version_name=str(cnd.version)),
title=f"View candidate {project.name} {cnd.version}",
)[
f"{project.name} {cnd.version} ",
@@ -586,7 +586,7 @@ async def _render_releases_sections(
preview_buttons.append(
htm.a(
".btn.btn-sm.btn-outline-warning.py-2.px-3",
- href=util.as_url(file.selected, project_name=project.name, version_name=prv.version),
+ href=util.as_url(file.selected, project_name=str(project.name), version_name=str(prv.version)),
title=f"View preview {project.name} {prv.version}",
)[
f"{project.name} {prv.version} ",
@@ -603,7 +603,7 @@ async def _render_releases_sections(
release_buttons.append(
htm.a(
".btn.btn-sm.btn-outline-success.py-2.px-3",
- href=util.as_url(file.selected, project_name=project.name, version_name=rel.version),
+ href=util.as_url(file.selected, project_name=str(project.name), version_name=str(rel.version)),
title=f"View release {project.name} {rel.version}",
)[
f"{project.name} {rel.version} ",
@@ -622,7 +622,7 @@ def _render_vote_form(project: sql.Project) -> htm.Element:
]
defaults_dict = {
- "project_name": project.name,
+ "project_name": str(project.name),
"github_vote_workflow_path": "\n".join(project.policy_github_vote_workflow_path),
"mailto_addresses": project.policy_mailto_addresses[0]
if project.policy_mailto_addresses
@@ -665,7 +665,7 @@ def _render_vote_form(project: sql.Project) -> htm.Element:
form.render_block(
card_body,
model_cls=shared.projects.VotePolicyForm,
- action=util.as_url(post.projects.view, name=project.name),
+ action=util.as_url(post.projects.view, name=str(project.name)),
submit_label="Save",
defaults=defaults_dict,
form_classes=".atr-canary.py-4.px-5",
diff --git a/atr/get/report.py b/atr/get/report.py
index 33b99686..15d81be6 100644
--- a/atr/get/report.py
+++ b/atr/get/report.py
@@ -52,16 +52,16 @@ async def selected_path(
# If the draft is not found, we try to get the release candidate
try:
release = await session.release(
- str(project_name),
- str(version_name),
+ project_name,
+ version_name,
with_committee=True,
with_release_policy=True,
with_project_release_policy=True,
)
except base.ASFQuartException:
release = await session.release(
- str(project_name),
- str(version_name),
+ project_name,
+ version_name,
phase=sql.ReleasePhase.RELEASE_CANDIDATE,
with_committee=True,
with_release_policy=True,
diff --git a/atr/get/result.py b/atr/get/result.py
index 2b936d36..eaf52f8a 100644
--- a/atr/get/result.py
+++ b/atr/get/result.py
@@ -49,7 +49,7 @@ async def data(
).get()
if release is None:
- release = await session.release(str(project_name), str(version_name), with_committee=True)
+ release = await session.release(project_name, version_name, with_committee=True)
if release.committee is None:
raise base.ASFQuartException("Release has no committee", errorcode=500)
diff --git a/atr/get/revisions.py b/atr/get/revisions.py
index 8bbb575a..7f324448 100644
--- a/atr/get/revisions.py
+++ b/atr/get/revisions.py
@@ -62,10 +62,10 @@ async def selected(
"""
await session.check_access(project_name)
try:
- release = await session.release(str(project_name), str(version_name))
+ release = await session.release(project_name, version_name)
phase_key = "draft"
except base.ASFQuartException:
- release = await session.release(str(project_name), str(version_name), phase=sql.ReleasePhase.RELEASE_PREVIEW)
+ release = await session.release(project_name, version_name, phase=sql.ReleasePhase.RELEASE_PREVIEW)
phase_key = "preview"
release_dir = paths.release_directory_base(release)
@@ -178,7 +178,7 @@ async def _render_page(
"Revisions of ",
htm.strong[release.project.short_display_name],
" ",
- htm.em[release.version],
+ htm.em[str(release.version)],
]
if revision_history:
diff --git a/atr/get/sbom.py b/atr/get/sbom.py
index cd9612a7..a8ef42cc 100644
--- a/atr/get/sbom.py
+++ b/atr/get/sbom.py
@@ -58,10 +58,10 @@ async def report(
"""
# If the draft is not found, we try to get the release candidate
try:
- release = await session.release(str(project_name), str(version_name), with_committee=True)
+ release = await session.release(project_name, version_name, with_committee=True)
except base.ASFQuartException:
release = await session.release(
- str(project_name), str(version_name), phase=sql.ReleasePhase.RELEASE_CANDIDATE, with_committee=True
+ project_name, version_name, phase=sql.ReleasePhase.RELEASE_CANDIDATE, with_committee=True
)
block = htm.Block()
@@ -95,9 +95,7 @@ async def report(
raise base.ASFQuartException("Invalid file path", errorcode=400)
validated_path_str = str(validated_path)
- task, augment_tasks, osv_tasks = await _fetch_tasks(
- validated_path_str, str(project_name), release, str(version_name)
- )
+ task, augment_tasks, osv_tasks = await _fetch_tasks(validated_path_str, project_name, release, version_name)
task_status = await _report_task_results(block, task)
if task_status:
@@ -247,15 +245,15 @@ def _extract_vulnerability_severity(vuln: results.VulnerabilityDetails) -> str:
async def _fetch_tasks(
- file_path: str, project: str, release: sql.Release, version: str
+ file_path: str, project: safe.ProjectName, release: sql.Release, version: safe.VersionName
) -> tuple[sql.Task | None, Sequence[sql.Task], Sequence[sql.Task]]:
# TODO: Abstract this code and the sbomtool.MissingAdapter validators
async with db.session() as data:
via = sql.validate_instrumented_attribute
tasks = (
await data.task(
- project_name=project,
- version_name=version,
+ project_name=str(project),
+ version_name=str(version),
revision_number=release.latest_revision_number,
task_type=sql.TaskType.SBOM_TOOL_SCORE,
primary_rel_path=file_path,
@@ -265,8 +263,8 @@ async def _fetch_tasks(
)
augment_tasks = (
await data.task(
- project_name=project,
- version_name=version,
+ project_name=str(project),
+ version_name=str(version),
task_type=sql.TaskType.SBOM_AUGMENT,
primary_rel_path=file_path,
)
@@ -276,8 +274,8 @@ async def _fetch_tasks(
# Run or running scans for the current revision
osv_tasks = (
await data.task(
- project_name=project,
- version_name=version,
+ project_name=str(project),
+ version_name=str(version),
task_type=sql.TaskType.SBOM_OSV_SCAN,
primary_rel_path=file_path,
revision_number=release.latest_revision_number,
diff --git a/atr/get/start.py b/atr/get/start.py
index 7e33a0fb..950204d4 100644
--- a/atr/get/start.py
+++ b/atr/get/start.py
@@ -63,7 +63,7 @@ def _existing_releases(ul: htm.Block, releases: list[sql.Release], max_revisions
htm.div(".text-nowrap")[
htm.span(class_="atr-phase-symbol fs-6")[phase_symbol],
" ",
- release.version,
+ str(release.version),
]
]
diff --git a/atr/get/test.py b/atr/get/test.py
index bdd4370b..f480e6b2 100644
--- a/atr/get/test.py
+++ b/atr/get/test.py
@@ -98,30 +98,30 @@ async def test_merge(
raise base.ASFQuartException("Test routes not enabled", errorcode=404)
async with storage.write(session) as write_n:
- wacp_n = await write_n.as_project_committee_participant(str(project_name))
+ wacp_n = await write_n.as_project_committee_participant(project_name)
async def modify_new(path_new: pathlib.Path, _old_rev_new: sql.Revision | None) -> None:
async with aiofiles.open(path_new / "from_new.txt", "w") as f:
await f.write("new content")
async with storage.write(session) as write_p:
- wacp_p = await write_p.as_project_committee_participant(str(project_name))
+ wacp_p = await write_p.as_project_committee_participant(project_name)
async def modify_prior(path_prior: pathlib.Path, _old_rev_prior: sql.Revision | None) -> None:
async with aiofiles.open(path_prior / "from_prior.txt", "w") as f:
await f.write("prior content")
await wacp_p.revision.create_revision_with_quarantine(
- str(project_name),
- str(version_name),
+ project_name,
+ version_name,
session.uid,
description="Test merge: prior revision",
modify=modify_prior,
)
await wacp_n.revision.create_revision_with_quarantine(
- str(project_name),
- str(version_name),
+ project_name,
+ version_name,
session.uid,
description="Test merge: new revision",
modify=modify_new,
@@ -129,8 +129,8 @@ async def test_merge(
files: list[str] = []
async with db.session() as data:
- release_name = sql.release_name(str(project_name), str(version_name))
- release = await data.release(name=release_name, _project=True).demand(
+ release_name = sql.release_name(project_name, version_name)
+ release = await data.release(name=str(release_name), _project=True).demand(
RuntimeError("Release not found after merge test")
)
release_dir = paths.release_directory(release)
@@ -232,7 +232,7 @@ async def test_vote(
if (user_category != vote.UserCategory.UNAUTHENTICATED) and (session is None):
raise base.ASFQuartException("You must be logged in to preview authenticated views", errorcode=401)
- _, release, latest_vote_task = await vote.category_and_release(session, str(project_name), str(version_name))
+ _, release, latest_vote_task = await vote.category_and_release(session, project_name, version_name)
if release.phase != sql.ReleasePhase.RELEASE_CANDIDATE:
raise base.ASFQuartException("Release is not a candidate", errorcode=404)
diff --git a/atr/get/upload.py b/atr/get/upload.py
index e8aaacb1..eec7aad8 100644
--- a/atr/get/upload.py
+++ b/atr/get/upload.py
@@ -49,7 +49,7 @@ async def selected(
"""
await session.check_access(project_name)
async with db.session() as data:
- release = await session.release(str(project_name), str(version_name), data=data)
+ release = await session.release(project_name, version_name, data=data)
user_ssh_keys = await data.ssh_key(asf_uid=session.uid).all()
block = htm.Block()
@@ -65,7 +65,7 @@ async def selected(
"Upload to ",
htm.strong[release.project.short_display_name],
" ",
- htm.em[release.version],
+ htm.em[str(release.version)],
]
block.p[
diff --git a/atr/get/vote.py b/atr/get/vote.py
index 22890514..636ba1c1 100644
--- a/atr/get/vote.py
+++ b/atr/get/vote.py
@@ -59,12 +59,12 @@ class UserCategory(enum.StrEnum):
async def category_and_release(
- session: web.Committer | None, project_name: str, version_name: str
+ session: web.Committer | None, project_name: safe.ProjectName, version_name: safe.VersionName
) -> tuple[UserCategory, sql.Release, sql.Task | None]:
async with db.session() as data:
release = await data.release(
- project_name=project_name,
- version=version_name,
+ project_name=str(project_name),
+ version=str(version_name),
_committee=True,
_project_release_policy=True,
).demand(base.ASFQuartException("Release does not exist", errorcode=404))
@@ -136,7 +136,7 @@ async def render_vote_closed_page(release: sql.Release) -> str:
"Vote closed for ",
htm.strong[release.project.short_display_name],
" ",
- htm.em[release.version],
+ htm.em[str(release.version)],
]
phase_messages = {
@@ -183,7 +183,7 @@ async def selected(
URL: /vote/<project_name>/<version_name>
Show voting options for a release candidate.
"""
- user_category, release, latest_vote_task = await category_and_release(session, str(project_name), str(version_name))
+ user_category, release, latest_vote_task = await category_and_release(session, project_name, version_name)
if release.phase != sql.ReleasePhase.RELEASE_CANDIDATE:
if session is None:
@@ -324,7 +324,7 @@ def _render_header(page: htm.Block, release: sql.Release, show_resolve_section:
"Vote on ",
htm.strong[release.project.short_display_name],
" ",
- htm.em[release.version],
+ htm.em[str(release.version)],
]
if release.committee is None:
diff --git a/atr/get/voting.py b/atr/get/voting.py
index 8c72cac8..a92c496d 100644
--- a/atr/get/voting.py
+++ b/atr/get/voting.py
@@ -55,7 +55,7 @@ async def selected_revision(
await session.check_access(project_name)
async with db.session() as data:
match await interaction.release_ready_for_vote(
- session, str(project_name), str(version_name), revision, data, manual_vote=False
+ session, project_name, version_name, revision, data, manual_vote=False
):
case str() as error:
return await session.redirect(
@@ -74,15 +74,15 @@ async def selected_revision(
if release.release_policy and (release.release_policy.min_hours is not None):
min_hours = release.release_policy.min_hours
- default_subject_template = await construct.start_vote_subject_default(str(project_name))
- default_body_template = await construct.start_vote_default(str(project_name))
+ default_subject_template = await construct.start_vote_subject_default(project_name)
+ default_body_template = await construct.start_vote_default(project_name)
subject_template_hash = construct.template_hash(default_subject_template)
options = construct.StartVoteOptions(
asfuid=session.uid,
fullname=session.fullname,
- project_name=str(project_name),
- version_name=release.version,
+ project_name=project_name,
+ version_name=release.safe_version_name,
revision_number=revision,
vote_duration=min_hours,
)
diff --git a/atr/merge.py b/atr/merge.py
index 68793eb1..81ddc81a 100644
--- a/atr/merge.py
+++ b/atr/merge.py
@@ -25,6 +25,7 @@ import aiofiles.os
import atr.attestable as attestable
import atr.hashes as hashes
+import atr.models.safe as safe
import atr.util as util
if TYPE_CHECKING:
@@ -35,8 +36,8 @@ async def merge(
base_inodes: dict[str, int],
base_hashes: dict[str, str],
prior_dir: pathlib.Path,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
prior_revision_number: str,
temp_dir: pathlib.Path,
n_inodes: dict[str, int],
@@ -119,8 +120,8 @@ async def _add_from_prior(
n_hashes: dict[str, str],
n_sizes: dict[str, int],
prior_hashes: dict[str, str] | None,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
prior_revision_number: str,
) -> dict[str, str] | None:
target = temp_dir / path
@@ -176,8 +177,8 @@ async def _merge_all_present(
n_hashes: dict[str, str],
n_sizes: dict[str, int],
prior_hashes: dict[str, str] | None,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
prior_revision_number: str,
) -> dict[str, str] | None:
# Cases 6, 8: prior and new share an inode so they already agree
@@ -237,8 +238,8 @@ async def _replace_with_prior(
n_hashes: dict[str, str],
n_sizes: dict[str, int],
prior_hashes: dict[str, str] | None,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
prior_revision_number: str,
) -> dict[str, str] | None:
await aiofiles.os.remove(temp_dir / path)
diff --git a/atr/models/__init__.py b/atr/models/__init__.py
index 0eea22ce..20d8698e 100644
--- a/atr/models/__init__.py
+++ b/atr/models/__init__.py
@@ -15,7 +15,7 @@
# specific language governing permissions and limitations
# under the License.
-from . import api, basic, distribution, github, helpers, results, schema, session, sql, tabulate, validation
+from . import api, basic, distribution, github, helpers, results, safe, schema, session, sql, tabulate, validation
# If we use .__name__, pyright gives a warning
__all__ = [
@@ -25,6 +25,7 @@ __all__ = [
"github",
"helpers",
"results",
+ "safe",
"schema",
"session",
"sql",
diff --git a/atr/models/api.py b/atr/models/api.py
index 9464a636..9d553b68 100644
--- a/atr/models/api.py
+++ b/atr/models/api.py
@@ -21,7 +21,7 @@ from typing import Annotated, Any, Literal, TypeVar
import pydantic
-from . import schema, sql, tabulate, validation
+from . import safe, schema, sql, tabulate, validation
T = TypeVar("T")
@@ -73,14 +73,14 @@ class DistributeSshRegisterArgs(schema.Strict):
ssh_key: str = schema.example("ssh-ed25519 AAAAC3NzaC1lZDI1NTEgH5C9okWi0dh25AAAAIOMqqnkVzrm0SdG6UOoqKLsabl9GKJl")
phase: str = schema.Field(strict=False, default="compose", json_schema_extra={"examples": ["compose", "finish"]})
asf_uid: str = schema.example("user")
- project_name: str = schema.example("tooling")
- version: str = schema.example("0.0.1")
+ project_name: safe.ProjectName = schema.example("tooling")
+ version: safe.VersionName = schema.example("0.0.1")
class DistributeSshRegisterResults(schema.Strict):
endpoint: Literal["/distribute/ssh/register"] = schema.alias("endpoint")
fingerprint: str = schema.example("SHA256:0123456789abcdef0123456789abcdef01234567")
- project: str = schema.example("example")
+ project: safe.ProjectName = schema.example("example")
expires: int = schema.example(1713547200)
@@ -89,7 +89,7 @@ class DistributeStatusUpdateArgs(schema.Strict):
jwt: str = schema.example("eyJhbGciOiJIUzI1[...]mMjLiuyu5CSpyHI=")
workflow: str = schema.description("Workflow name")
run_id: str = schema.description("Workflow run ID")
- project_name: str = schema.description("Project name in ATR")
+ project_name: safe.ProjectName = schema.description("Project name in ATR")
status: str = schema.description("Workflow status")
message: str = schema.description("Workflow message")
@@ -100,8 +100,8 @@ class DistributeStatusUpdateResults(schema.Strict):
class DistributionRecordArgs(schema.Strict):
- project: str = schema.example("example")
- version: str = schema.example("0.0.1")
+ project: safe.ProjectName = schema.example("example")
+ version: safe.VersionName = schema.example("0.0.1")
platform: sql.DistributionPlatform = schema.example(sql.DistributionPlatform.ARTIFACT_HUB)
distribution_owner_namespace: str | None = schema.default_example(None, "example")
distribution_package: str = schema.example("example")
@@ -128,8 +128,8 @@ class DistributionRecordFromWorkflowArgs(schema.Strict):
asf_uid: str = schema.example("user")
publisher: str = schema.example("user")
jwt: str = schema.example("eyJhbGciOiJIUzI1[...]mMjLiuyu5CSpyHI=")
- project: str = schema.example("example")
- version: str = schema.example("0.0.1")
+ project: safe.ProjectName = schema.example("example")
+ version: safe.VersionName = schema.example("0.0.1")
platform: sql.DistributionPlatform = schema.example(sql.DistributionPlatform.ARTIFACT_HUB)
distribution_owner_namespace: str | None = schema.default_example(None, "example")
distribution_package: str = schema.example("example")
@@ -164,7 +164,7 @@ class DistributionRecordResults(schema.Strict):
class IgnoreAddArgs(schema.Strict):
- project_name: str = schema.example("example")
+ project_name: safe.ProjectName = schema.example("example")
release_glob: str | None = schema.default_example(None, "example-0.0.*")
revision_number: str | None = schema.default_example(None, "00001")
checker_glob: str | None = schema.default_example(None, "atr.tasks.checks.license.files")
@@ -194,7 +194,7 @@ class IgnoreAddResults(schema.Strict):
class IgnoreDeleteArgs(schema.Strict):
- project_name: str = schema.example("example")
+ project_name: safe.ProjectName = schema.example("example")
id: int = schema.example(1)
@@ -289,7 +289,7 @@ class ProjectGetResults(schema.Strict):
class ProjectPolicyResults(schema.Strict):
endpoint: Literal["/project/policy"] = schema.alias("endpoint")
- project_name: str
+ project_name: safe.ProjectName
policy_announce_release_subject: str
policy_announce_release_template: str
policy_binary_artifact_paths: list[str]
@@ -325,7 +325,7 @@ class ProjectsListResults(schema.Strict):
class PublisherDistributionRecordArgs(schema.Strict):
publisher: str = schema.example("user")
jwt: str = schema.example("eyJhbGciOiJIUzI1[...]mMjLiuyu5CSpyHI=")
- version: str = schema.example("0.0.1")
+ version: safe.VersionName = schema.example("0.0.1")
platform: sql.DistributionPlatform = schema.example(sql.DistributionPlatform.ARTIFACT_HUB)
distribution_owner_namespace: str | None = schema.default_example(None, "example")
distribution_package: str = schema.example("example")
@@ -356,7 +356,7 @@ class PublisherDistributionRecordResults(schema.Strict):
class PublisherReleaseAnnounceArgs(schema.Strict):
publisher: str = schema.example("user")
jwt: str = schema.example("eyJhbGciOiJIUzI1[...]mMjLiuyu5CSpyHI=")
- version: str = schema.example("0.0.1")
+ version: safe.VersionName = schema.example("0.0.1")
revision: str = schema.example("00005")
email_to: str = schema.example("dev@example.apache.org")
body: str = schema.example("The Apache Example team is pleased to announce the release of Example 1.0.0...")
@@ -377,14 +377,14 @@ class PublisherSshRegisterArgs(schema.Strict):
class PublisherSshRegisterResults(schema.Strict):
endpoint: Literal["/publisher/ssh/register"] = schema.alias("endpoint")
fingerprint: str = schema.example("SHA256:0123456789abcdef0123456789abcdef01234567")
- project: str = schema.example("example")
+ project: safe.ProjectName = schema.example("example")
expires: int = schema.example(1713547200)
class PublisherVoteResolveArgs(schema.Strict):
publisher: str = schema.example("user")
jwt: str = schema.example("eyJhbGciOiJIUzI1[...]mMjLiuyu5CSpyHI=")
- version: str = schema.example("0.0.1")
+ version: safe.VersionName = schema.example("0.0.1")
resolution: Literal["passed", "failed"] = schema.example("passed")
@@ -394,8 +394,8 @@ class PublisherVoteResolveResults(schema.Strict):
class ReleaseAnnounceArgs(schema.Strict):
- project: str = schema.example("example")
- version: str = schema.example("1.0.0")
+ project: safe.ProjectName = schema.example("example")
+ version: safe.VersionName = schema.example("1.0.0")
revision: str = schema.example("00005")
email_to: str = schema.example("dev@example.apache.org")
body: str = schema.example("The Apache Example team is pleased to announce the release of Example 1.0.0...")
@@ -408,8 +408,8 @@ class ReleaseAnnounceResults(schema.Strict):
class ReleaseDraftDeleteArgs(schema.Strict):
- project: str = schema.example("example")
- version: str = schema.example("0.0.1")
+ project: safe.ProjectName = schema.example("example")
+ version: safe.VersionName = schema.example("0.0.1")
class ReleaseDraftDeleteResults(schema.Strict):
@@ -418,7 +418,7 @@ class ReleaseDraftDeleteResults(schema.Strict):
class ReleaseCreateArgs(schema.Strict):
- project: str = schema.example("example")
+ project: safe.ProjectName = schema.example("example")
version: str = schema.example("0.0.1")
@@ -428,8 +428,8 @@ class ReleaseCreateResults(schema.Strict):
class ReleaseDeleteArgs(schema.Strict):
- project: str = schema.example("example")
- version: str = schema.example("0.0.1")
+ project: safe.ProjectName = schema.example("example")
+ version: safe.VersionName = schema.example("0.0.1")
class ReleaseDeleteResults(schema.Strict):
@@ -466,8 +466,8 @@ class ReleaseRevisionsResults(schema.Strict):
class ReleaseUploadArgs(schema.Strict):
- project: str = schema.example("example")
- version: str = schema.example("0.0.1")
+ project: safe.ProjectName = schema.example("example")
+ version: safe.VersionName = schema.example("0.0.1")
relpath: str = schema.example("example/0.0.1/example-0.0.1-bin.tar.gz")
content: str = schema.example("This is the content of the file.")
@@ -568,8 +568,8 @@ class UsersListResults(schema.Strict):
class VoteResolveArgs(schema.Strict):
- project: str = schema.example("example")
- version: str = schema.example("0.0.1")
+ project: safe.ProjectName = schema.example("example")
+ version: safe.VersionName = schema.example("0.0.1")
resolution: Literal["passed", "failed"] = schema.example("passed")
@@ -579,8 +579,8 @@ class VoteResolveResults(schema.Strict):
class VoteStartArgs(schema.Strict):
- project: str = schema.example("example")
- version: str = schema.example("0.0.1")
+ project: safe.ProjectName = schema.example("example")
+ version: safe.VersionName = schema.example("0.0.1")
revision: str = schema.example("00005")
email_to: str = schema.example("dev@example.apache.org")
vote_duration: int = schema.example(10)
@@ -594,8 +594,8 @@ class VoteStartResults(schema.Strict):
class VoteTabulateArgs(schema.Strict):
- project: str = schema.example("example")
- version: str = schema.example("0.0.1")
+ project: safe.ProjectName = schema.example("example")
+ version: safe.VersionName = schema.example("0.0.1")
class VoteTabulateResults(schema.Strict):
diff --git a/atr/models/results.py b/atr/models/results.py
index eeb73b93..a2576b5e 100644
--- a/atr/models/results.py
+++ b/atr/models/results.py
@@ -19,7 +19,7 @@ from typing import Annotated, Any, Literal
import pydantic
-from . import schema
+from . import safe, schema
class DistributionStatusCheck(schema.Strict):
@@ -105,8 +105,8 @@ class OSVComponent(schema.Strict):
class SBOMOSVScan(schema.Strict):
kind: Literal["sbom_osv_scan"] = schema.Field(alias="kind")
- project_name: str = schema.description("Project name")
- version_name: str = schema.description("Version name")
+ project_name: safe.ProjectName = schema.description("Project name")
+ version_name: safe.VersionName = schema.description("Version name")
revision_number: str = schema.description("Revision number")
bom_version: int | None = schema.Field(
default=None, strict=False, description="BOM Version produced with scan results"
@@ -165,8 +165,8 @@ class SBOMAugment(schema.Strict):
class SBOMQsScore(schema.Strict):
kind: Literal["sbom_qs_score"] = schema.Field(alias="kind")
- project_name: str = schema.description("Project name")
- version_name: str = schema.description("Version name")
+ project_name: safe.ProjectName = schema.description("Project name")
+ version_name: safe.VersionName = schema.description("Version name")
revision_number: str = schema.description("Revision number")
file_path: str = schema.description("Relative path to the scored SBOM file")
report: SbomQsReport
@@ -174,8 +174,8 @@ class SBOMQsScore(schema.Strict):
class SBOMToolScore(schema.Strict):
kind: Literal["sbom_tool_score"] = schema.Field(alias="kind")
- project_name: str = schema.description("Project name")
- version_name: str = schema.description("Version name")
+ project_name: safe.ProjectName = schema.description("Project name")
+ version_name: safe.VersionName = schema.description("Version name")
revision_number: str = schema.description("Revision number")
bom_version: int | None = schema.Field(default=None, strict=False, description="BOM Version scanned")
prev_bom_version: int | None = schema.Field(
diff --git a/atr/models/safe.py b/atr/models/safe.py
index c6f9893b..d07ba289 100644
--- a/atr/models/safe.py
+++ b/atr/models/safe.py
@@ -15,6 +15,15 @@
# specific language governing permissions and limitations
# under the License.
+from __future__ import annotations
+
+from typing import Any
+
+import atr.cache as cache
+import atr.db as db
+
+# TODO: I think we should probably add some standard syntactic validations to all of the safe types too, like completely disallowing U+0000 and other control characters, requiring NFC, disallowing markup characters, and so on. Then we can rely on those when we handle safe types anywhere.
+
class ProjectName:
"""A project name that has been validated against the cache or database."""
@@ -24,6 +33,15 @@ class ProjectName:
def __init__(self, value: str) -> None:
self._value = value
+ @classmethod
+ async def create(cls, value: str) -> ProjectName | None:
+ if not cache.project_version_has_project(value):
+ async with db.session() as data:
+ project = await data.project(name=value).get()
+ if project is None:
+ return None
+ return cls(value)
+
def __eq__(self, other: object) -> bool:
if isinstance(other, ProjectName):
return self._value == other._value
@@ -38,6 +56,47 @@ class ProjectName:
def __str__(self) -> str:
return self._value
+ @classmethod
+ def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> Any:
+ import pydantic_core.core_schema as core_schema
+
+ return core_schema.no_info_plain_validator_function(
+ lambda v: cls(v) if isinstance(v, str) else v,
+ serialization=core_schema.to_string_ser_schema(),
+ )
+
+
+class ReleaseName:
+ """A release name composed from a validated ProjectName and VersionName."""
+
+ __slots__ = ("_value",)
+
+ def __init__(self, value: str) -> None:
+ self._value = value
+
+ def __eq__(self, other: object) -> bool:
+ if isinstance(other, ReleaseName):
+ return self._value == other._value
+ return NotImplemented
+
+ def __hash__(self) -> int:
+ return hash(self._value)
+
+ def __repr__(self) -> str:
+ return f"ReleaseName({self._value!r})"
+
+ def __str__(self) -> str:
+ return self._value
+
+ @classmethod
+ def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> Any:
+ import pydantic_core.core_schema as core_schema
+
+ return core_schema.no_info_plain_validator_function(
+ lambda v: cls(v) if isinstance(v, str) else v,
+ serialization=core_schema.to_string_ser_schema(),
+ )
+
class VersionName:
"""A version name that has been validated against the cache or database."""
@@ -47,6 +106,22 @@ class VersionName:
def __init__(self, value: str) -> None:
self._value = value
+ @classmethod
+ async def create(
+ cls,
+ value: str,
+ project: ProjectName,
+ ) -> VersionName | None:
+ if not cache.project_version_has_version(project, value):
+ async with db.session() as data:
+ release = await data.release(
+ project_name=str(project),
+ version=value,
+ ).get()
+ if release is None:
+ return None
+ return cls(value)
+
def __eq__(self, other: object) -> bool:
if isinstance(other, VersionName):
return self._value == other._value
@@ -60,3 +135,12 @@ class VersionName:
def __str__(self) -> str:
return self._value
+
+ @classmethod
+ def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> Any:
+ import pydantic_core.core_schema as core_schema
+
+ return core_schema.no_info_plain_validator_function(
+ lambda v: cls(v) if isinstance(v, str) else v,
+ serialization=core_schema.to_string_ser_schema(),
+ )
diff --git a/atr/models/sql.py b/atr/models/sql.py
index cbb875b8..36e49baa 100644
--- a/atr/models/sql.py
+++ b/atr/models/sql.py
@@ -24,7 +24,7 @@
import dataclasses
import datetime
import enum
-from typing import Any, Final, Literal, Optional, TypeVar
+from typing import Any, Final, Literal, Optional, TypeVar, overload
import pydantic
import sqlalchemy
@@ -34,7 +34,7 @@ import sqlalchemy.orm as orm
import sqlalchemy.sql.expression as expression
import sqlmodel
-from . import results, schema
+from . import results, safe, schema
T = TypeVar("T")
@@ -264,6 +264,49 @@ class VoteEntry(schema.Strict):
# Type decorators
# TODO: Possibly move these to a separate module
# That way, we can more easily track Alembic's dependence on them
+class SafeProjectName(sqlalchemy.types.TypeDecorator):
+ impl = sqlalchemy.types.String
+ cache_ok = True
+
+ def process_bind_param(self, value, dialect):
+ if value is None:
+ return None
+ return str(value)
+
+ def process_result_value(self, value, dialect):
+ if value is None:
+ return None
+ return safe.ProjectName(value)
+
+
+class SafeReleaseName(sqlalchemy.types.TypeDecorator):
+ impl = sqlalchemy.types.String
+ cache_ok = True
+
+ def process_bind_param(self, value, dialect):
+ if value is None:
+ return None
+ return str(value)
+
+ def process_result_value(self, value, dialect):
+ if value is None:
+ return None
+ return safe.ReleaseName(value)
+
+
+class SafeVersionName(sqlalchemy.types.TypeDecorator):
+ impl = sqlalchemy.types.String
+ cache_ok = True
+
+ def process_bind_param(self, value, dialect):
+ if value is None:
+ return None
+ return str(value)
+
+ def process_result_value(self, value, dialect):
+ if value is None:
+ return None
+ return safe.VersionName(value)
class UTCDateTime(sqlalchemy.types.TypeDecorator):
@@ -549,7 +592,7 @@ def see_also(arg: Any) -> None:
class Project(sqlmodel.SQLModel, table=True):
# TODO: Consider using key or label for primary string keys
# Then we can use simply "name" for full_name, and make it str rather than str | None
- name: str = sqlmodel.Field(unique=True, primary_key=True, **example("example"))
+ name: str = sqlmodel.Field(primary_key=True, unique=True, **example("example"))
# TODO: Ideally full_name would be unique for str only, but that's complex
# We always include "Apache" in the full_name
full_name: str | None = sqlmodel.Field(default=None, **example("Apache Example"))
@@ -598,11 +641,16 @@ class Project(sqlmodel.SQLModel, table=True):
@property
def display_name(self) -> str:
"""Get the display name for the Project."""
- base = self.full_name or self.name
+ base = self.full_name or str(self.name)
if self.committee and self.committee.is_podling:
return f"{base} (Incubating)"
return base
+ @property
+ def safe_name(self) -> safe.ProjectName:
+ """Get the typesafe validated name for the Project"""
+ return safe.ProjectName(self.name)
+
@property
def short_display_name(self) -> str:
"""Get the short display name for the Project."""
@@ -917,6 +965,21 @@ class Release(sqlmodel.SQLModel, table=True):
# return None
return project.committee
+ @property
+ def safe_name(self) -> safe.ReleaseName:
+ """Get the typesafe validated name for the Release"""
+ return safe.ReleaseName(self.name)
+
+ @property
+ def safe_project_name(self) -> safe.ProjectName:
+ """Get the typesafe validated name for the release project"""
+ return safe.ProjectName(self.project_name)
+
+ @property
+ def safe_version_name(self) -> safe.VersionName:
+ """Get the typesafe validated name for the release version"""
+ return safe.VersionName(self.project_name)
+
@property
def short_display_name(self) -> str:
"""Get the short display name for the release."""
@@ -1023,7 +1086,7 @@ class CheckResultIgnore(sqlmodel.SQLModel, table=True):
# Distribution: Release
class Distribution(sqlmodel.SQLModel, table=True):
- release_name: str = sqlmodel.Field(primary_key=True, index=True, foreign_key="release.name", ondelete="CASCADE")
+ release_name: str = sqlmodel.Field(foreign_key="release.name", ondelete="CASCADE", primary_key=True, index=True)
release: Release = sqlmodel.Relationship(back_populates="distributions")
platform: DistributionPlatform = sqlmodel.Field(primary_key=True, index=True)
owner_namespace: str = sqlmodel.Field(primary_key=True, index=True, default="")
@@ -1050,6 +1113,11 @@ class Distribution(sqlmodel.SQLModel, table=True):
version = normal(self.version)
return f"{name}-{package}-{version}"
+ @property
+ def safe_release_name(self) -> safe.ReleaseName:
+ """Get the typesafe validated name for the distribution release"""
+ return safe.ReleaseName(self.release_name)
+
@property
def title(self) -> str:
return f"{self.platform.value.name} {self.package} {self.version}"
@@ -1314,7 +1382,7 @@ class WorkflowStatus(sqlmodel.SQLModel, table=True):
message: str | None = sqlmodel.Field(default=None)
-def revision_name(release_name: str, number: str) -> str:
+def revision_name(release_name: safe.ReleaseName | str, number: str) -> str:
return f"{release_name} {number}"
@@ -1385,9 +1453,20 @@ def latest_revision_number_query(release_name: str | None = None) -> expression.
)
-def release_name(project_name: str, version_name: str) -> str:
+@overload
+def release_name(project_name: safe.ProjectName, version_name: safe.VersionName) -> safe.ReleaseName: ...
+
+
+@overload
+def release_name(project_name: str, version_name: str) -> str: ...
+
+
+def release_name(project_name: safe.ProjectName | str, version_name: safe.VersionName | str) -> safe.ReleaseName | str:
"""Return the release name for a given project and version."""
- return f"{project_name}-{version_name}"
+ name = f"{project_name}-{version_name}"
+ if isinstance(project_name, safe.ProjectName) and isinstance(version_name, safe.VersionName):
+ return safe.ReleaseName(name)
+ return name
def validate_instrumented_attribute(obj: Any) -> orm.InstrumentedAttribute:
diff --git a/atr/paths.py b/atr/paths.py
index 2c089e26..ff6b2b06 100644
--- a/atr/paths.py
+++ b/atr/paths.py
@@ -17,12 +17,15 @@
import pathlib
-from atr import config as config
-from atr.models import sql as sql
+import atr.config as config
+import atr.models.safe as safe
+import atr.models.sql as sql
-def base_path_for_revision(project_name: str, version_name: str, revision: str) -> pathlib.Path:
- return pathlib.Path(get_unfinished_dir(), project_name, version_name, revision)
+def base_path_for_revision(
+ project_name: safe.ProjectName, version_name: safe.VersionName, revision: str
+) -> pathlib.Path:
+ return pathlib.Path(get_unfinished_dir(), str(project_name), str(version_name), revision)
def get_attestable_dir() -> pathlib.Path:
@@ -64,7 +67,7 @@ def quarantine_directory(quarantined: sql.Quarantined) -> pathlib.Path:
if not quarantined.token.isalnum():
raise ValueError("Invalid quarantine token")
release = quarantined.release
- return get_quarantined_dir() / release.project_name / release.version / quarantined.token
+ return get_quarantined_dir() / str(release.project_name) / str(release.version) / quarantined.token
def release_directory(release: sql.Release) -> pathlib.Path:
@@ -92,7 +95,7 @@ def release_directory_base(release: sql.Release) -> pathlib.Path:
case sql.ReleasePhase.RELEASE:
base_dir = get_finished_dir()
# Do not add "case _" here
- return base_dir / project_name / version_name
+ return base_dir / str(project_name) / str(version_name)
def release_directory_revision(release: sql.Release) -> pathlib.Path | None:
@@ -107,9 +110,9 @@ def release_directory_revision(release: sql.Release) -> pathlib.Path | None:
):
if (path_revision := release.latest_revision_number) is None:
return None
- path = get_unfinished_dir() / path_project / path_version / path_revision
+ path = get_unfinished_dir() / str(path_project) / str(path_version) / path_revision
case sql.ReleasePhase.RELEASE:
- path = get_finished_dir() / path_project / path_version
+ path = get_finished_dir() / str(path_project) / str(path_version)
# Do not add "case _" here
return path
@@ -124,12 +127,14 @@ def release_directory_version(release: sql.Release) -> pathlib.Path:
| sql.ReleasePhase.RELEASE_CANDIDATE
| sql.ReleasePhase.RELEASE_PREVIEW
):
- path = get_unfinished_dir() / path_project / path_version
+ path = get_unfinished_dir() / str(path_project) / str(path_version)
case sql.ReleasePhase.RELEASE:
- path = get_finished_dir() / path_project / path_version
+ path = get_finished_dir() / str(path_project) / str(path_version)
# Do not add "case _" here
return path
-def revision_path_for_file(project_name: str, version_name: str, revision: str, file_name: str) -> pathlib.Path:
+def revision_path_for_file(
+ project_name: safe.ProjectName, version_name: safe.VersionName, revision: str, file_name: str
+) -> pathlib.Path:
return base_path_for_revision(project_name, version_name, revision) / file_name
diff --git a/atr/post/announce.py b/atr/post/announce.py
index 417c0dd6..f988b40a 100644
--- a/atr/post/announce.py
+++ b/atr/post/announce.py
@@ -53,8 +53,8 @@ async def selected(
# Get the release to find the revision number
release = await session.release(
- str(project_name),
- str(version_name),
+ project_name,
+ version_name,
with_committee=True,
phase=sql.ReleasePhase.RELEASE_PREVIEW,
with_distributions=True,
@@ -92,7 +92,7 @@ async def selected(
)
# Validate that the subject template hasn't changed
- subject_template = await construct.announce_release_subject_default(str(project_name))
+ subject_template = await construct.announce_release_subject_default(project_name)
current_hash = construct.template_hash(subject_template)
if current_hash != announce_form.subject_template_hash:
return await session.form_error(
@@ -101,10 +101,10 @@ async def selected(
)
try:
- async with storage.write_as_project_committee_member(str(project_name), session) as wacm:
+ async with storage.write_as_project_committee_member(project_name, session) as wacm:
await wacm.announce.release(
- project_name=str(project_name),
- version_name=str(version_name),
+ project_name=project_name,
+ version_name=version_name,
preview_revision_number=preview_revision_number,
recipient=announce_form.mailing_list,
body=announce_form.body,
diff --git a/atr/post/distribution.py b/atr/post/distribution.py
index 3e4f0b5a..01f847ca 100644
--- a/atr/post/distribution.py
+++ b/atr/post/distribution.py
@@ -41,8 +41,8 @@ _AUTOMATED_PLATFORMS_STAGE: Final[tuple[shared.distribution.DistributionPlatform
async def automate_form_process_page(
session: web.Committer,
form_data: shared.distribution.DistributeForm,
- project: str,
- version: str,
+ project: safe.ProjectName,
+ version: safe.VersionName,
/,
staging: bool = False,
) -> web.WerkzeugResponse:
@@ -51,8 +51,8 @@ async def automate_form_process_page(
platform_str = form_data.platform.value
return await session.redirect(
get.distribution.stage_automate if staging else get.distribution.automate,
- project_name=project,
- version_name=version,
+ project_name=str(project),
+ version_name=str(version),
error=f"Platform {platform_str} is not supported for automated distribution",
)
sql_platform = form_data.platform.to_sql() # type: ignore[attr-defined]
@@ -77,7 +77,7 @@ async def automate_form_process_page(
async with storage.write_as_committee_member(committee_name=committee.name) as w:
try:
await w.distributions.automate(
- release.name,
+ release.safe_name,
dd.platform,
committee.name,
dd.owner_namespace,
@@ -120,9 +120,7 @@ async def automate_selected(
URL: /distribution/automate/<project_name>/<version_name>
"""
await session.check_access(project_name)
- return await automate_form_process_page(
- session, distribute_form, str(project_name), str(version_name), staging=False
- )
+ return await automate_form_process_page(session, distribute_form, project_name, version_name, staging=False)
@post.typed
@@ -141,7 +139,7 @@ async def delete(
# Validate the submitted data, and obtain the committee for its name
async with db.session() as data:
- release = await data.release(name=delete_form.release_name).demand(
+ release = await data.release(name=str(delete_form.release_name)).demand(
RuntimeError(f"Release {delete_form.release_name} not found")
)
committee = release.committee
@@ -168,8 +166,8 @@ async def delete(
async def record_form_process_page(
session: web.Committer,
form_data: shared.distribution.DistributeForm,
- project: str,
- version: str,
+ project: safe.ProjectName,
+ version: safe.VersionName,
/,
staging: bool = False,
) -> web.WerkzeugResponse:
@@ -190,7 +188,7 @@ async def record_form_process_page(
async with storage.write_as_committee_member(committee_name=committee.name) as w:
try:
_dist, added, _metadata = await w.distributions.record_from_data(
- release_name=release.name,
+ release_name=release.safe_name,
staging=staging,
dd=dd,
allow_retries=False,
@@ -199,8 +197,8 @@ async def record_form_process_page(
# Instead of calling record_form_page_new, redirect with error message
return await session.redirect(
get.distribution.stage_record if staging else get.distribution.record,
- project_name=project,
- version_name=version,
+ project_name=str(project),
+ version_name=str(version),
error=str(e),
)
@@ -208,8 +206,8 @@ async def record_form_process_page(
message = "Distribution recorded successfully." if added else "Distribution was already recorded."
return await session.redirect(
get.distribution.list_get,
- project_name=project,
- version_name=version,
+ project_name=str(project),
+ version_name=str(version),
success=message,
)
@@ -225,7 +223,7 @@ async def record_selected(
"""
URL: /distribution/record/<project_name>/<version_name>
"""
- return await record_form_process_page(session, distribute_form, str(project_name), str(version_name), staging=False)
+ return await record_form_process_page(session, distribute_form, project_name, version_name, staging=False)
@post.typed
@@ -239,9 +237,7 @@ async def stage_automate_selected(
"""
URL: /distribution/stage/automate/<project_name>/<version_name>
"""
- return await automate_form_process_page(
- session, distribute_form, str(project_name), str(version_name), staging=True
- )
+ return await automate_form_process_page(session, distribute_form, project_name, version_name, staging=True)
@post.typed
@@ -255,4 +251,4 @@ async def stage_record_selected(
"""
URL: /distribution/stage/record/<project_name>/<version_name>
"""
- return await record_form_process_page(session, distribute_form, str(project_name), str(version_name), staging=True)
+ return await record_form_process_page(session, distribute_form, project_name, version_name, staging=True)
diff --git a/atr/post/draft.py b/atr/post/draft.py
index 533b5242..a47ccddf 100644
--- a/atr/post/draft.py
+++ b/atr/post/draft.py
@@ -57,10 +57,10 @@ async def cache_reset(
description = "Empty revision to restart all checks without cache for the whole release candidate draft"
async with storage.write(session) as write:
- wacp = await write.as_project_committee_participant(str(project_name))
+ wacp = await write.as_project_committee_participant(project_name)
result = await wacp.revision.create_revision_with_quarantine(
- str(project_name),
- str(version_name),
+ project_name,
+ version_name,
session.uid,
description=description,
reset_to_global_cache=True,
@@ -91,10 +91,10 @@ async def delete(
"""
# Delete the metadata from the database
async with storage.write(session) as write:
- wacp = await write.as_project_committee_participant(str(project_name))
+ wacp = await write.as_project_committee_participant(project_name)
error = await wacp.release.delete(
- str(project_name),
- str(version_name),
+ project_name,
+ version_name,
phase=sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT,
include_downloads=False,
)
@@ -129,10 +129,8 @@ async def delete_file(
try:
async with storage.write(session) as write:
- wacp = await write.as_project_committee_participant(str(project_name))
- metadata_files_deleted = await wacp.release.delete_file(
- str(project_name), str(version_name), rel_path_to_delete
- )
+ wacp = await write.as_project_committee_participant(project_name)
+ metadata_files_deleted = await wacp.release.delete_file(project_name, version_name, rel_path_to_delete)
except Exception as e:
log.exception("Error deleting file:")
await quart.flash(f"Error deleting file: {e!s}", "error")
@@ -170,8 +168,8 @@ async def hashgen(
try:
async with storage.write(session) as write:
- wacp = await write.as_project_committee_participant(str(project_name))
- await wacp.release.generate_hash_file(str(project_name), str(version_name), rel_path)
+ wacp = await write.as_project_committee_participant(project_name)
+ await wacp.release.generate_hash_file(project_name, version_name, rel_path)
except Exception as e:
log.exception("Error generating hash file:")
@@ -205,10 +203,10 @@ async def recheck(
description = "Empty revision to restart all checks without cache for the whole release candidate draft"
async with storage.write(session) as write:
- wacp = await write.as_project_committee_participant(str(project_name))
+ wacp = await write.as_project_committee_participant(project_name)
result = await wacp.revision.create_revision_with_quarantine(
- str(project_name),
- str(version_name),
+ project_name,
+ version_name,
session.uid,
description=description,
set_local_cache=True,
@@ -259,7 +257,7 @@ async def sbomgen(
try:
description = "SBOM generation through web interface"
async with storage.write(session) as write:
- wacp = await write.as_project_committee_participant(str(project_name))
+ wacp = await write.as_project_committee_participant(project_name)
async def modify(path: pathlib.Path, old_rev: sql.Revision | None) -> None:
path_in_new_revision = path / rel_path
@@ -281,8 +279,8 @@ async def sbomgen(
# Create and queue the task, using paths within the new revision
sbom_task = await wacp.sbom.generate_cyclonedx(
- str(project_name),
- str(version_name),
+ project_name,
+ version_name,
old_rev.number,
path_in_new_revision,
sbom_path_in_new_revision,
@@ -292,7 +290,7 @@ async def sbomgen(
raise web.FlashError("Internal error: SBOM generation timed out")
result = await wacp.revision.create_revision_with_quarantine(
- str(project_name), str(version_name), session.uid, description=description, modify=modify
+ project_name, version_name, session.uid, description=description, modify=modify
)
except Exception as e:
diff --git a/atr/post/finish.py b/atr/post/finish.py
index fa438c87..74c26a13 100644
--- a/atr/post/finish.py
+++ b/atr/post/finish.py
@@ -40,22 +40,22 @@ async def selected(
URL: /finish/<project_name>/<version_name>
"""
wants_json = quart.request.accept_mimetypes.best_match(["application/json", "text/html"]) == "application/json"
- respond = _respond_helper(session, str(project_name), str(version_name), wants_json)
+ respond = _respond_helper(session, project_name, version_name, wants_json)
match finish_form:
case shared.finish.DeleteEmptyDirectoryForm() as delete_form:
- return await _delete_empty_directory(delete_form, session, str(project_name), str(version_name), respond)
+ return await _delete_empty_directory(delete_form, session, project_name, version_name, respond)
case shared.finish.MoveFileForm() as move_form:
- return await _move_file_to_revision(move_form, session, str(project_name), str(version_name), respond)
+ return await _move_file_to_revision(move_form, session, project_name, version_name, respond)
case shared.finish.RemoveRCTagsForm():
- return await _remove_rc_tags(session, str(project_name), str(version_name), respond)
+ return await _remove_rc_tags(session, project_name, version_name, respond)
async def _delete_empty_directory(
delete_form: shared.finish.DeleteEmptyDirectoryForm,
session: web.Committer,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
respond: shared.finish.Respond,
) -> tuple[web.QuartResponse, int] | web.WerkzeugResponse:
dir_to_delete_rel = delete_form.directory_to_delete
@@ -77,8 +77,8 @@ async def _delete_empty_directory(
async def _move_file_to_revision(
move_form: shared.finish.MoveFileForm,
session: web.Committer,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
respond: shared.finish.Respond,
) -> tuple[web.QuartResponse, int] | web.WerkzeugResponse:
source_files_rel = move_form.source_files
@@ -122,8 +122,8 @@ async def _move_file_to_revision(
async def _remove_rc_tags(
session: web.Committer,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
respond: shared.finish.Respond,
) -> tuple[web.QuartResponse, int] | web.WerkzeugResponse:
try:
@@ -154,7 +154,7 @@ async def _remove_rc_tags(
def _respond_helper(
- session: web.Committer, project_name: str, version_name: str, wants_json: bool
+ session: web.Committer, project_name: safe.ProjectName, version_name: safe.VersionName, wants_json: bool
) -> shared.finish.Respond:
"""Create a response helper function for the finish route."""
import atr.get as get
@@ -167,6 +167,8 @@ def _respond_helper(
if wants_json:
return quart.jsonify(ok=ok, message=msg), http_status
await quart.flash(msg, "success" if ok else "error")
- return await session.redirect(get.finish.selected, project_name=project_name, version_name=version_name)
+ return await session.redirect(
+ get.finish.selected, project_name=str(project_name), version_name=str(version_name)
+ )
return respond
diff --git a/atr/post/ignores.py b/atr/post/ignores.py
index 30c2a2f8..92f37734 100644
--- a/atr/post/ignores.py
+++ b/atr/post/ignores.py
@@ -40,17 +40,17 @@ async def ignores(
await session.check_access(project_name)
match ignore_form:
case shared.ignores.AddIgnoreForm() as add_form:
- return await _add_ignore(session, add_form, str(project_name))
+ return await _add_ignore(session, add_form, project_name)
case shared.ignores.DeleteIgnoreForm() as delete_form:
- return await _delete_ignore(session, delete_form, str(project_name))
+ return await _delete_ignore(session, delete_form, project_name)
case shared.ignores.UpdateIgnoreForm() as update_form:
- return await _update_ignore(session, update_form, str(project_name))
+ return await _update_ignore(session, update_form, project_name)
async def _add_ignore(
- session: web.Committer, add_form: shared.ignores.AddIgnoreForm, project_name: str
+ session: web.Committer, add_form: shared.ignores.AddIgnoreForm, project_name: safe.ProjectName
) -> web.WerkzeugResponse:
"""Add a new ignore."""
status = shared.ignores.ignore_status_to_sql(add_form.status) # pyright: ignore[reportArgumentType]
@@ -70,13 +70,13 @@ async def _add_ignore(
return await session.redirect(
get.ignores.ignores,
- project_name=project_name,
+ project_name=str(project_name),
success="Ignore added",
)
async def _delete_ignore(
- session: web.Committer, delete_form: shared.ignores.DeleteIgnoreForm, project_name: str
+ session: web.Committer, delete_form: shared.ignores.DeleteIgnoreForm, project_name: safe.ProjectName
) -> web.WerkzeugResponse:
"""Delete an ignore."""
async with storage.write() as write:
@@ -85,13 +85,13 @@ async def _delete_ignore(
return await session.redirect(
get.ignores.ignores,
- project_name=project_name,
+ project_name=str(project_name),
success="Ignore deleted",
)
async def _update_ignore(
- session: web.Committer, update_form: shared.ignores.UpdateIgnoreForm, project_name: str
+ session: web.Committer, update_form: shared.ignores.UpdateIgnoreForm, project_name: safe.ProjectName
) -> web.WerkzeugResponse:
"""Update an ignore."""
status = shared.ignores.ignore_status_to_sql(update_form.status) # pyright: ignore[reportArgumentType]
@@ -111,6 +111,6 @@ async def _update_ignore(
return await session.redirect(
get.ignores.ignores,
- project_name=project_name,
+ project_name=str(project_name),
success="Ignore updated",
)
diff --git a/atr/post/keys.py b/atr/post/keys.py
index 6a3939c4..58396458 100644
--- a/atr/post/keys.py
+++ b/atr/post/keys.py
@@ -151,8 +151,8 @@ async def import_selected_revision(
"""
await session.check_access(project_name)
async with storage.write() as write:
- wacm = await write.as_project_committee_member(str(project_name))
- outcomes: outcome.List[types.Key] = await wacm.keys.import_keys_file(str(project_name), str(version_name))
+ wacm = await write.as_project_committee_member(project_name)
+ outcomes: outcome.List[types.Key] = await wacm.keys.import_keys_file(project_name, version_name)
message = f"Uploaded {util.plural(outcomes.result_count, 'key')}"
if outcomes.error_count > 0:
diff --git a/atr/post/manual.py b/atr/post/manual.py
index 9d001a04..4fd8a06e 100644
--- a/atr/post/manual.py
+++ b/atr/post/manual.py
@@ -43,8 +43,8 @@ async def resolve_selected(
Post the manual vote resolution page.
"""
release = await session.release(
- str(project_name),
- str(version_name),
+ project_name,
+ version_name,
phase=sql.ReleasePhase.RELEASE_CANDIDATE,
with_release_policy=True,
with_project_release_policy=True,
@@ -70,8 +70,8 @@ async def resolve_selected(
vote_result = "failed"
destination = get.compose.selected
- async with storage.write_as_project_committee_member(str(project_name)) as wacm:
- success_message = await wacm.vote.resolve_manually(str(project_name), str(version_name), vote_result)
+ async with storage.write_as_project_committee_member(project_name) as wacm:
+ success_message = await wacm.vote.resolve_manually(project_name, version_name, vote_result)
return await session.redirect(
destination,
@@ -96,7 +96,7 @@ async def start_selected_revision(
async with db.session() as data:
match await interaction.release_ready_for_vote(
- session, str(project_name), str(version_name), revision, data, manual_vote=True
+ session, project_name, version_name, revision, data, manual_vote=True
):
case str() as error:
return await session.redirect(
@@ -109,8 +109,8 @@ async def start_selected_revision(
pass
async with storage.write(session) as write:
- wacp = await write.as_project_committee_participant(release.project_name)
- error = await wacp.release.promote_to_candidate(release.name, revision, vote_manual=True)
+ wacp = await write.as_project_committee_participant(release.safe_project_name)
+ error = await wacp.release.promote_to_candidate(release.safe_name, revision, vote_manual=True)
if error:
return await session.redirect(
diff --git a/atr/post/projects.py b/atr/post/projects.py
index 9a2295d7..68f9d878 100644
--- a/atr/post/projects.py
+++ b/atr/post/projects.py
@@ -25,6 +25,7 @@ import quart
import atr.blueprints.post as post
import atr.db as db
import atr.get as get
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.shared as shared
import atr.storage as storage
@@ -44,8 +45,9 @@ async def add_project(
display_name = project_form.display_name
label = project_form.label
+ # TODO: Is this right? Name is unvalidated
async with storage.write(session) as write:
- wacm = await write.as_project_committee_member(committee_name)
+ wacm = await write.as_project_committee_member(safe.ProjectName(committee_name))
try:
await wacm.project.create(committee_name, display_name, label)
except storage.AccessError as e:
@@ -167,17 +169,17 @@ async def _process_add_category(
async with storage.write(session) as write:
wacm = await write.as_project_committee_member(project_name)
async with db.session() as data:
- project = await data.project(name=project_name).demand(
+ project = await data.project(name=str(project_name)).demand(
base.ASFQuartException(f"Project {project_name} not found", errorcode=404)
)
modified = await _metadata_category_add(wacm, project, category_to_add)
if modified:
return await session.redirect(
- get.projects.view, project_name=project_name, success=f"Category '{category_to_add}' added."
+ get.projects.view, project_name=str(project_name), success=f"Category '{category_to_add}' added."
)
return await session.redirect(
- get.projects.view, project_name=project_name, error=f"Category '{category_to_add}' already exists."
+ get.projects.view, project_name=str(project_name), error=f"Category '{category_to_add}' already exists."
)
@@ -190,17 +192,17 @@ async def _process_add_language(
async with storage.write(session) as write:
wacm = await write.as_project_committee_member(project_name)
async with db.session() as data:
- project = await data.project(name=project_name).demand(
+ project = await data.project(name=str(project_name)).demand(
base.ASFQuartException(f"Project {project_name} not found", errorcode=404)
)
modified = await _metadata_language_add(wacm, project, language_to_add)
if modified:
return await session.redirect(
- get.projects.view, project_name=project_name, success=f"Language '{language_to_add}' added."
+ get.projects.view, project_name=str(project_name), success=f"Language '{language_to_add}' added."
)
return await session.redirect(
- get.projects.view, project_name=project_name, error=f"Language '{language_to_add}' already exists."
+ get.projects.view, project_name=str(project_name), error=f"Language '{language_to_add}' already exists."
)
@@ -266,17 +268,17 @@ async def _process_remove_category(
async with storage.write(session) as write:
wacm = await write.as_project_committee_member(project_name)
async with db.session() as data:
- project = await data.project(name=project_name).demand(
+ project = await data.project(name=str(project_name)).demand(
base.ASFQuartException(f"Project {project_name} not found", errorcode=404)
)
modified = await _metadata_category_remove(wacm, project, category_to_remove)
if modified:
return await session.redirect(
- get.projects.view, project_name=project_name, success=f"Category '{category_to_remove}' removed."
+ get.projects.view, project_name=str(project_name), success=f"Category '{category_to_remove}' removed."
)
return await session.redirect(
- get.projects.view, project_name=project_name, error=f"Category '{category_to_remove}' does not exist."
+ get.projects.view, project_name=str(project_name), error=f"Category '{category_to_remove}' does not exist."
)
@@ -289,7 +291,7 @@ async def _process_remove_language(
async with storage.write(session) as write:
wacm = await write.as_project_committee_member(project_name)
async with db.session() as data:
- project = await data.project(name=project_name).demand(
+ project = await data.project(name=str(project_name)).demand(
base.ASFQuartException(f"Project {project_name} not found", errorcode=404)
)
modified = await _metadata_language_remove(wacm, project, language_to_remove)
diff --git a/atr/post/resolve.py b/atr/post/resolve.py
index a631f6f5..5ee74f9c 100644
--- a/atr/post/resolve.py
+++ b/atr/post/resolve.py
@@ -46,14 +46,17 @@ async def selected(
"""
match resolve_form:
case shared.resolve.SubmitForm() as submit_form:
- return await _submit(session, submit_form, str(project_name), str(version_name))
+ return await _submit(session, submit_form, project_name, version_name)
case shared.resolve.TabulateForm():
- return await _tabulate(session, str(project_name), str(version_name))
+ return await _tabulate(session, project_name, version_name)
async def _submit(
- session: web.Committer, submit_form: shared.resolve.SubmitForm, project_name: str, version_name: str
+ session: web.Committer,
+ submit_form: shared.resolve.SubmitForm,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
) -> web.WerkzeugResponse:
email_body = submit_form.email_body
vote_result = submit_form.vote_result
@@ -78,11 +81,11 @@ async def _submit(
destination = get.compose.selected
return await session.redirect(
- destination, project_name=project_name, version_name=version_name, success=success_message
+ destination, project_name=str(project_name), version_name=str(version_name), success=success_message
)
-async def _tabulate(session: web.Committer, project_name: str, version_name: str) -> str:
+async def _tabulate(session: web.Committer, project_name: safe.ProjectName, version_name: safe.VersionName) -> str:
asf_uid = session.uid
full_name = session.fullname
@@ -142,7 +145,7 @@ async def _tabulate(session: web.Committer, project_name: str, version_name: str
resolve_form = atr.form.render(
model_cls=shared.resolve.SubmitForm,
- action=util.as_url(selected, project_name=release.project.name, version_name=release.version),
+ action=util.as_url(selected, project_name=str(release.project.name), version_name=str(release.version)),
submit_label="Resolve vote",
textarea_rows=24,
defaults=defaults,
diff --git a/atr/post/revisions.py b/atr/post/revisions.py
index 72f6497d..a89a22ac 100644
--- a/atr/post/revisions.py
+++ b/atr/post/revisions.py
@@ -41,13 +41,16 @@ async def selected_post(
"""
match revision_form:
case shared.revisions.SetRevisionForm():
- return await _set_revision(session, revision_form, str(project_name), str(version_name))
+ return await _set_revision(session, revision_form, project_name, version_name)
case shared.revisions.SetTagForm():
- return await _set_tag(session, revision_form, str(project_name), str(version_name))
+ return await _set_tag(session, revision_form, project_name, version_name)
async def _set_revision(
- session: web.Committer, set_revision_form: shared.revisions.SetRevisionForm, project_name: str, version_name: str
+ session: web.Committer,
+ set_revision_form: shared.revisions.SetRevisionForm,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
) -> web.WerkzeugResponse:
"""Set a specific revision as the latest for a candidate draft or release preview."""
selected_revision_number = set_revision_form.revision_number
@@ -80,13 +83,16 @@ async def _set_revision(
return await session.redirect(
get.revisions.selected,
success=success,
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
)
async def _set_tag(
- session: web.Committer, set_tag_form: shared.revisions.SetTagForm, project_name: str, version_name: str
+ session: web.Committer,
+ set_tag_form: shared.revisions.SetTagForm,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
) -> web.WerkzeugResponse:
"""Set a tag on a specific revision."""
revision_number = set_tag_form.revision_number
@@ -106,6 +112,6 @@ async def _set_tag(
return await session.redirect(
get.revisions.selected,
success=message,
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
)
diff --git a/atr/post/sbom.py b/atr/post/sbom.py
index 4f614b0e..d3aeb28b 100644
--- a/atr/post/sbom.py
+++ b/atr/post/sbom.py
@@ -57,14 +57,14 @@ async def report(
match sbom_form:
case shared.sbom.AugmentSBOMForm():
- return await _augment(session, str(project_name), str(version_name), validated_path)
+ return await _augment(session, project_name, version_name, validated_path)
case shared.sbom.ScanSBOMForm():
- return await _scan(session, str(project_name), str(version_name), validated_path)
+ return await _scan(session, project_name, version_name, validated_path)
async def _augment(
- session: web.Committer, project_name: str, version_name: str, rel_path: pathlib.Path
+ session: web.Committer, project_name: safe.ProjectName, version_name: safe.VersionName, rel_path: pathlib.Path
) -> web.WerkzeugResponse:
"""Augment a CycloneDX SBOM file."""
# Check that the file is a .cdx.json archive before creating a revision
@@ -73,7 +73,7 @@ async def _augment(
try:
async with db.session() as data:
- release = await data.release(project_name=project_name, version=version_name).demand(
+ release = await data.release(project_name=str(project_name), version=str(version_name)).demand(
RuntimeError("Release does not exist for new revision creation")
)
revision_number = release.latest_revision_number
@@ -108,7 +108,7 @@ async def _augment(
async def _scan(
- session: web.Committer, project_name: str, version_name: str, rel_path: pathlib.Path
+ session: web.Committer, project_name: safe.ProjectName, version_name: safe.VersionName, rel_path: pathlib.Path
) -> web.WerkzeugResponse:
"""Scan a CycloneDX SBOM file for vulnerabilities using OSV."""
if not (rel_path.name.endswith(".cdx.json")):
@@ -116,7 +116,7 @@ async def _scan(
try:
async with db.session() as data:
- release = await data.release(project_name=project_name, version=version_name).demand(
+ release = await data.release(project_name=str(project_name), version=str(version_name)).demand(
RuntimeError("Release does not exist for OSV scan")
)
revision_number = release.latest_revision_number
diff --git a/atr/post/start.py b/atr/post/start.py
index fea9a2f2..1ff31372 100644
--- a/atr/post/start.py
+++ b/atr/post/start.py
@@ -40,9 +40,9 @@ async def selected(
try:
async with storage.write(session) as write:
- wacp = await write.as_project_committee_participant(str(project_name))
+ wacp = await write.as_project_committee_participant(project_name)
new_release, _project = await wacp.release.start(
- str(project_name),
+ project_name,
start_release_form.version_name,
)
diff --git a/atr/post/upload.py b/atr/post/upload.py
index 9c4c2cb9..54b1a056 100644
--- a/atr/post/upload.py
+++ b/atr/post/upload.py
@@ -74,7 +74,7 @@ async def finalise(
try:
async with storage.write(session) as write:
- wacp = await write.as_project_committee_participant(str(project_name))
+ wacp = await write.as_project_committee_participant(project_name)
number_of_files = len(staged_files)
description = f"Upload of {util.plural(number_of_files, 'file')} through web interface"
@@ -85,7 +85,7 @@ async def finalise(
await aioshutil.move(str(src), str(dst))
result = await wacp.revision.create_revision_with_quarantine(
- str(project_name), str(version_name), session.uid, description=description, modify=modify
+ project_name, version_name, session.uid, description=description, modify=modify
)
await aioshutil.rmtree(staging_dir)
@@ -131,10 +131,10 @@ async def selected(
match upload_form:
case shared.upload.AddFilesForm() as add_form:
- return await _add_files(session, add_form, str(project_name), str(version_name))
+ return await _add_files(session, add_form, project_name, version_name)
case shared.upload.SvnImportForm() as svn_form:
- return await _svn_import(session, svn_form, str(project_name), str(version_name))
+ return await _svn_import(session, svn_form, project_name, version_name)
@post.typed
@@ -187,7 +187,10 @@ async def stage(
async def _add_files(
- session: web.Committer, add_form: shared.upload.AddFilesForm, project_name: str, version_name: str
+ session: web.Committer,
+ add_form: shared.upload.AddFilesForm,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
) -> web.WerkzeugResponse:
try:
file_name = add_form.file_name
@@ -248,7 +251,10 @@ def _json_success(data: dict[str, str], status: int = 200) -> web.WerkzeugRespon
async def _svn_import(
- session: web.Committer, svn_form: shared.upload.SvnImportForm, project_name: str, version_name: str
+ session: web.Committer,
+ svn_form: shared.upload.SvnImportForm,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
) -> web.WerkzeugResponse:
# audit_guidance any file uploads are from known and managed repositories so file size is not an issue
try:
@@ -259,7 +265,7 @@ async def _svn_import(
async with db.session() as data:
release = await session.release(project_name, version_name, data=data)
is_podling = (release.project.committee is not None) and release.project.committee.is_podling
- committee_name = release.project.committee_name or project_name
+ committee_name = release.project.committee_name or str(project_name)
svn_url = _construct_svn_url(
committee_name,
diff --git a/atr/post/vote.py b/atr/post/vote.py
index 894fbc69..b6d99c87 100644
--- a/atr/post/vote.py
+++ b/atr/post/vote.py
@@ -40,7 +40,7 @@ async def selected_post(
URL: /vote/<project_name>/<version_name>
"""
- release = await session.release(str(project_name), str(version_name), phase=sql.ReleasePhase.RELEASE_CANDIDATE)
+ release = await session.release(project_name, version_name, phase=sql.ReleasePhase.RELEASE_CANDIDATE)
if release.committee is None:
raise ValueError("Release has no committee")
diff --git a/atr/post/voting.py b/atr/post/voting.py
index 26a701b4..bed6534e 100644
--- a/atr/post/voting.py
+++ b/atr/post/voting.py
@@ -50,14 +50,14 @@ async def body_preview(
URL: /voting/body/preview/<project_name>/<version_name>/<revision_number>
"""
- default_subject_template = await construct.start_vote_subject_default(str(project_name))
- default_body_template = await construct.start_vote_default(str(project_name))
+ default_subject_template = await construct.start_vote_subject_default(project_name)
+ default_body_template = await construct.start_vote_default(project_name)
options = construct.StartVoteOptions(
asfuid=session.uid,
fullname=session.fullname,
- project_name=str(project_name),
- version_name=str(version_name),
+ project_name=project_name,
+ version_name=version_name,
revision_number=revision_number,
vote_duration=preview_form.vote_duration,
)
@@ -81,7 +81,7 @@ async def selected_revision(
async with db.session() as data:
match await interaction.release_ready_for_vote(
- session, str(project_name), str(version_name), revision, data, manual_vote=False
+ session, project_name, version_name, revision, data, manual_vote=False
):
case str() as error:
return await session.redirect(
@@ -101,7 +101,7 @@ async def selected_revision(
f"Invalid mailing list selection: {start_voting_form.mailing_list}",
)
- subject_template = await construct.start_vote_subject_default(str(project_name))
+ subject_template = await construct.start_vote_subject_default(project_name)
current_hash = construct.template_hash(subject_template)
if current_hash != start_voting_form.subject_template_hash:
return await session.form_error(
@@ -113,8 +113,8 @@ async def selected_revision(
options = construct.StartVoteOptions(
asfuid=session.uid,
fullname=session.fullname,
- project_name=str(project_name),
- version_name=str(version_name),
+ project_name=project_name,
+ version_name=version_name,
revision_number=revision,
vote_duration=start_voting_form.vote_duration,
)
@@ -123,8 +123,8 @@ async def selected_revision(
async with storage.write_as_committee_participant(committee.name) as wacp:
_task = await wacp.vote.start(
start_voting_form.mailing_list,
- str(project_name),
- str(version_name),
+ project_name,
+ version_name,
revision,
start_voting_form.vote_duration,
subject,
diff --git a/atr/shared/distribution.py b/atr/shared/distribution.py
index 6408f94f..84b150ee 100644
--- a/atr/shared/distribution.py
+++ b/atr/shared/distribution.py
@@ -29,6 +29,7 @@ import atr.form as form
import atr.htm as htm
import atr.models.basic as basic
import atr.models.distribution as distribution
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.util as util
from atr.storage import outcome
@@ -114,7 +115,7 @@ class DistributionPlatform(enum.Enum):
class DeleteForm(form.Form):
- release_name: str = form.label("Release name", widget=form.Widget.HIDDEN)
+ release_name: safe.ReleaseName = form.label("Release name", widget=form.Widget.HIDDEN)
platform: form.Enum[DistributionPlatform] = form.label("Platform", widget=form.Widget.HIDDEN)
owner_namespace: str = form.label("Owner namespace", widget=form.Widget.HIDDEN)
package: str = form.label("Package", widget=form.Widget.HIDDEN)
@@ -362,7 +363,11 @@ async def json_from_maven_xml(api_url: str, version: str) -> outcome.Outcome[bas
async def release_validated(
- project: str, version: str, committee: bool = False, staging: bool | None = None, release_policy: bool = False
+ project: safe.ProjectName,
+ version: safe.VersionName,
+ committee: bool = False,
+ staging: bool | None = None,
+ release_policy: bool = False,
) -> sql.Release:
match staging:
case True:
@@ -373,20 +378,20 @@ async def release_validated(
phase = {sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT, sql.ReleasePhase.RELEASE_PREVIEW}
async with db.session() as data:
release = await data.release(
- project_name=project,
- version=version,
+ project_name=str(project),
+ version=str(version),
_committee=committee,
_release_policy=release_policy,
- ).demand(RuntimeError(f"Release {project} {version} not found"))
+ ).demand(RuntimeError(f"Release {project!s} {version!s} not found"))
if release.phase not in phase:
- raise RuntimeError(f"Release {project} {version} is not in {phase}")
+ raise RuntimeError(f"Release {project!s} {version!s} is not in {phase}")
# if release.project.status != sql.ProjectStatus.ACTIVE:
# raise RuntimeError(f"Project {project} is not active")
return release
async def release_validated_and_committee(
- project: str, version: str, *, staging: bool | None = None, release_policy: bool = False
+ project: safe.ProjectName, version: safe.VersionName, *, staging: bool | None = None, release_policy: bool = False
) -> tuple[sql.Release, sql.Committee]:
release = await release_validated(project, version, committee=True, staging=staging, release_policy=release_policy)
committee = release.committee
diff --git a/atr/shared/projects.py b/atr/shared/projects.py
index 88162e64..f09f0d81 100644
--- a/atr/shared/projects.py
+++ b/atr/shared/projects.py
@@ -23,6 +23,7 @@ from typing import Annotated, Literal
import pydantic
import atr.form as form
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.util as util
@@ -105,7 +106,7 @@ class AddProjectForm(form.Form):
class ComposePolicyForm(form.Form):
variant: COMPOSE = form.value(COMPOSE)
- project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+ project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
source_artifact_paths: str = form.label(
"Source artifact paths",
"Paths to source artifacts to be included in the release.",
@@ -181,7 +182,7 @@ class ComposePolicyForm(form.Form):
class VotePolicyForm(form.Form):
variant: VOTE = form.value(VOTE)
- project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+ project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
github_vote_workflow_path: str = form.label(
"GitHub vote workflow paths",
"The full paths to the GitHub workflows to use for the release, including the .github/workflows/ prefix.",
@@ -243,7 +244,7 @@ class VotePolicyForm(form.Form):
class FinishPolicyForm(form.Form):
variant: FINISH = form.value(FINISH)
- project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+ project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
github_finish_workflow_path: str = form.label(
"GitHub finish workflow paths",
"The full paths to the GitHub workflows to use for the release, including the .github/workflows/ prefix.",
@@ -277,35 +278,35 @@ class FinishPolicyForm(form.Form):
class AddCategoryForm(form.Form):
variant: ADD_CATEGORY = form.value(ADD_CATEGORY)
- project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+ project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
category_to_add: str = form.label("New category name")
class RemoveCategoryForm(form.Form):
variant: REMOVE_CATEGORY = form.value(REMOVE_CATEGORY)
- project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+ project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
category_to_remove: str = form.label("Category to remove", widget=form.Widget.HIDDEN)
class AddLanguageForm(form.Form):
variant: ADD_LANGUAGE = form.value(ADD_LANGUAGE)
- project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+ project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
language_to_add: str = form.label("New language name")
class RemoveLanguageForm(form.Form):
variant: REMOVE_LANGUAGE = form.value(REMOVE_LANGUAGE)
- project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+ project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
language_to_remove: str = form.label("Language to remove", widget=form.Widget.HIDDEN)
class DeleteProjectForm(form.Form):
variant: DELETE_PROJECT = form.value(DELETE_PROJECT)
- project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+ project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
class DeleteSelectedProject(form.Form):
- project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+ project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
type ProjectViewForm = Annotated[
diff --git a/atr/shared/web.py b/atr/shared/web.py
index 2ac53e23..fc38b0a8 100644
--- a/atr/shared/web.py
+++ b/atr/shared/web.py
@@ -24,6 +24,7 @@ import atr.form as form
import atr.get as get
import atr.htm as htm
import atr.models.results as results
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.paths as paths
import atr.post as post
@@ -38,6 +39,59 @@ if TYPE_CHECKING:
from collections.abc import Sequence
+def render_checks_summary(
+ info: types.PathInfo | None, project_name: safe.ProjectName, version_name: safe.VersionName
+) -> htm.Element | None:
+ if (info is None) or (not info.checker_stats):
+ return None
+
+ card = htm.Block(htm.div, classes=".card.mb-4")
+ card.div(".card-header")[htpy.h5(".mb-0")["Checks summary"]]
+
+ body = htm.Block(htm.div, classes=".card-body")
+ for i, stat in enumerate(info.checker_stats):
+ stripe_class = ".atr-stripe-odd" if ((i % 2) == 0) else ".atr-stripe-even"
+ details = htm.Block(htm.details, classes=f".mb-0.p-2{stripe_class}")
+
+ summary_content: list[htm.Element | str] = []
+ if stat.warning_count > 0:
+ summary_content.append(htpy.span(".badge.bg-warning.text-dark.me-2")[str(stat.warning_count)])
+ if stat.failure_count > 0:
+ summary_content.append(htpy.span(".badge.bg-danger.me-2")[str(stat.failure_count)])
+ if stat.blocker_count > 0:
+ summary_content.append(htpy.span(".badge.atr-bg-blocker.me-2")[str(stat.blocker_count)])
+ summary_content.append(htpy.strong[_checker_display_name(stat.checker)])
+
+ details.summary[*summary_content]
+
+ files_div = htm.Block(htm.div, classes=".mt-2.atr-checks-files")
+ all_files = set(stat.failure_files.keys()) | set(stat.warning_files.keys()) | set(stat.blocker_files.keys())
+ for file_path in sorted(all_files):
+ report_url = f"/report/{project_name!s}/{version_name!s}/{file_path}"
+ error_count = stat.failure_files.get(file_path, 0)
+ blocker_count = stat.blocker_files.get(file_path, 0)
+ warning_count = stat.warning_files.get(file_path, 0)
+
+ file_content: list[htm.Element | str] = []
+ if error_count > 0:
+ file_content.append(htpy.span(".badge.bg-danger.me-2")[util.plural(error_count, "error")])
+ if blocker_count > 0:
+ file_content.append(htpy.span(".badge.atr-bg-blocker.me-2")[util.plural(blocker_count, "blocker")])
+ if warning_count > 0:
+ file_content.append(
+ htpy.span(".badge.bg-warning.text-dark.me-2")[util.plural(warning_count, "warning")]
+ )
+ file_content.append(htpy.a(href=report_url)[htpy.strong[htpy.code[file_path]]])
+
+ files_div.div[*file_content]
+
+ details.append(files_div.collect())
+ body.append(details.collect())
+
+ card.append(body.collect())
+ return card.collect()
+
+
async def check(
session: web.Committer | None,
release: sql.Release,
@@ -80,11 +134,11 @@ async def check(
# Get the number of ongoing tasks for the current revision
ongoing_tasks_count = 0
- match await interaction.latest_info(release.project.name, release.version):
+ match await interaction.latest_info(release.safe_project_name, release.safe_version_name):
case (revision_number, revision_editor, revision_timestamp):
ongoing_tasks_count = await interaction.tasks_ongoing(
- release.project.name,
- release.version,
+ release.safe_project_name,
+ release.safe_version_name,
revision_number,
)
case None:
@@ -94,7 +148,9 @@ async def check(
delete_form = form.render(
model_cls=form.Empty,
- action=util.as_url(get.compose.selected, project_name=release.project.name, version_name=release.version),
+ action=util.as_url(
+ get.compose.selected, project_name=release.safe_project_name, version_name=release.safe_version_name
+ ),
submit_label="Delete this draft",
submit_classes="btn btn-danger",
empty=True,
@@ -105,7 +161,9 @@ async def check(
for path in all_paths:
delete_file_forms[str(path)] = form.render(
model_cls=draft.DeleteFileForm,
- action=util.as_url(post.draft.delete_file, project_name=release.project.name, version_name=release.version),
+ action=util.as_url(
+ post.draft.delete_file, project_name=release.safe_project_name, version_name=release.safe_version_name
+ ),
form_classes=".d-inline-block.m-0",
submit_classes="btn-sm btn-outline-danger",
submit_label="Delete",
@@ -121,14 +179,18 @@ async def check(
recheck_form = form.render(
model_cls=form.Empty,
- action=util.as_url(post.draft.recheck, project_name=release.project.name, version_name=release.version),
+ action=util.as_url(
+ post.draft.recheck, project_name=release.safe_project_name, version_name=release.safe_version_name
+ ),
submit_label="Disable global cache",
submit_classes="btn btn-primary",
# confirm="Restart all checks without using cached results? This creates a new revision.",
)
cache_reset_form = form.render(
model_cls=form.Empty,
- action=util.as_url(post.draft.cache_reset, project_name=release.project.name, version_name=release.version),
+ action=util.as_url(
+ post.draft.cache_reset, project_name=release.safe_project_name, version_name=release.safe_version_name
+ ),
submit_label="Enable global cache",
submit_classes="btn btn-primary",
# confirm="Restart all checks without using cached results? This creates a new revision.",
@@ -146,12 +208,12 @@ async def check(
is_local_caching = release.check_cache_key is not None
- checks_summary_html = render_checks_summary(info, release.project.name, release.version)
+ checks_summary_html = render_checks_summary(info, release.safe_project_name, release.safe_version_name)
return await template.render(
"check-selected.html",
- project_name=release.project.name,
- version_name=release.version,
+ project_name=str(release.project.name),
+ version_name=str(release.version),
release=release,
paths=all_paths,
info=info,
@@ -188,57 +250,6 @@ async def check(
)
-def render_checks_summary(info: types.PathInfo | None, project_name: str, version_name: str) -> htm.Element | None:
- if (info is None) or (not info.checker_stats):
- return None
-
- card = htm.Block(htm.div, classes=".card.mb-4")
- card.div(".card-header")[htpy.h5(".mb-0")["Checks summary"]]
-
- body = htm.Block(htm.div, classes=".card-body")
- for i, stat in enumerate(info.checker_stats):
- stripe_class = ".atr-stripe-odd" if ((i % 2) == 0) else ".atr-stripe-even"
- details = htm.Block(htm.details, classes=f".mb-0.p-2{stripe_class}")
-
- summary_content: list[htm.Element | str] = []
- if stat.warning_count > 0:
- summary_content.append(htpy.span(".badge.bg-warning.text-dark.me-2")[str(stat.warning_count)])
- if stat.failure_count > 0:
- summary_content.append(htpy.span(".badge.bg-danger.me-2")[str(stat.failure_count)])
- if stat.blocker_count > 0:
- summary_content.append(htpy.span(".badge.atr-bg-blocker.me-2")[str(stat.blocker_count)])
- summary_content.append(htpy.strong[_checker_display_name(stat.checker)])
-
- details.summary[*summary_content]
-
- files_div = htm.Block(htm.div, classes=".mt-2.atr-checks-files")
- all_files = set(stat.failure_files.keys()) | set(stat.warning_files.keys()) | set(stat.blocker_files.keys())
- for file_path in sorted(all_files):
- report_url = f"/report/{project_name!s}/{version_name!s}/{file_path}"
- error_count = stat.failure_files.get(file_path, 0)
- blocker_count = stat.blocker_files.get(file_path, 0)
- warning_count = stat.warning_files.get(file_path, 0)
-
- file_content: list[htm.Element | str] = []
- if error_count > 0:
- file_content.append(htpy.span(".badge.bg-danger.me-2")[util.plural(error_count, "error")])
- if blocker_count > 0:
- file_content.append(htpy.span(".badge.atr-bg-blocker.me-2")[util.plural(blocker_count, "blocker")])
- if warning_count > 0:
- file_content.append(
- htpy.span(".badge.bg-warning.text-dark.me-2")[util.plural(warning_count, "warning")]
- )
- file_content.append(htpy.a(href=report_url)[htpy.strong[htpy.code[file_path]]])
-
- files_div.div[*file_content]
-
- details.append(files_div.collect())
- body.append(details.collect())
-
- card.append(body.collect())
- return card.collect()
-
-
def _checker_display_name(checker: str) -> str:
return checker.removeprefix("atr.tasks.checks.").replace("_", " ").replace(".", " ").title()
diff --git a/atr/ssh.py b/atr/ssh.py
index 25714bce..017dcc63 100644
--- a/atr/ssh.py
+++ b/atr/ssh.py
@@ -40,6 +40,7 @@ import atr.attestable as attestable
import atr.config as config
import atr.db as db
import atr.log as log
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.paths as paths
import atr.storage as storage
@@ -61,6 +62,12 @@ _APPROVED_KEX: Final = util.intersect_algs(_SSH_AUDIT_POLICY, "kex", _ASYNCSSH_S
_APPROVED_MACS: Final = util.intersect_algs(_SSH_AUDIT_POLICY, "macs", _ASYNCSSH_SUPPORTED_MAC)
+_PATH_ALPHANUM: Final = frozenset(string.ascii_letters + string.digits + "-")
+# From a survey of version numbers we find that only . and - are used
+# We also allow + which is in common use
+_PATH_VERSION_CHARS: Final = _PATH_ALPHANUM | frozenset(".-+")
+
+
class RsyncArgsError(Exception):
"""Exception raised when the rsync arguments are invalid."""
@@ -271,9 +278,9 @@ async def _step_02_handle_safely(process: asyncssh.SSHServerProcess, server: SSH
process, argv, is_read_request, server
)
# The release object is only present for read requests
- release_name = sql.release_name(project_name, version_name)
if release_obj is not None:
+ release_name = sql.release_name(project_name, version_name)
log.info(f"Processing READ request for {release_name}")
####################################################
### Calls _step_07a_process_validated_rsync_read ###
@@ -333,26 +340,24 @@ def _step_03_command_simple_validate(argv: list[str]) -> bool:
async def _step_04_command_validate(
process: asyncssh.SSHServerProcess, argv: list[str], is_read_request: bool, server: SSHServer
-) -> tuple[str, str, list[str] | None, sql.Release | None]:
+) -> tuple[safe.ProjectName, safe.VersionName | None, list[str] | None, sql.Release | None]:
"""Validate the path and user permissions for read or write."""
############################################
### Calls _step_05a/b_command_path_validate ###
############################################
if is_read_request:
- path_project, path_version, tag = _step_05a_command_path_validate_read(argv[-1])
+ project_name, version_name, tag = await _step_05a_command_path_validate_read(argv[-1])
else:
- path_project, path_version, tag = _step_05b_command_path_validate_write(argv[-1])
+ project_name, version_name, tag = await _step_05b_command_path_validate_write(argv[-1])
ssh_uid = server._get_asf_uid(process)
-
async with db.session() as data:
- project = await data.project(name=path_project, status=sql.ProjectStatus.ACTIVE, _committee=True).get()
+ project = await data.project(name=str(project_name), status=sql.ProjectStatus.ACTIVE, _committee=True).get()
if project is None:
- # Projects are public, so existence information is public
- raise RsyncArgsError(f"Project '{path_project}' does not exist")
+ raise RsyncArgsError(f"Project '{project_name}' does not exist")
release = await data.release(
- project_name=project.name, version=path_version, _project_release_policy=True
+ project_name=str(project_name), version=str(version_name), _project_release_policy=True
).get()
if is_read_request:
@@ -360,115 +365,102 @@ async def _step_04_command_validate(
### Calls _step_06a_validate_read_permissions ###
#################################################
validated_release, file_patterns = await _step_06a_validate_read_permissions(
- ssh_uid, project, release, path_project, path_version, tag
+ ssh_uid, project, release, project_name, version_name, tag
)
- return path_project, path_version, file_patterns, validated_release
+ return project_name, version_name, file_patterns, validated_release
##################################################
### Calls _step_06b_validate_write_permissions ###
##################################################
await _step_06b_validate_write_permissions(ssh_uid, project, release)
- # Return None for the tag and release objects for write requests
- return path_project, path_version, None, None
+ return project_name, version_name, None, None
-def _step_05a_command_path_validate_read(path: str) -> tuple[str, str, str | None]:
- """Validate the path argument for rsync commands."""
+async def _step_05a_command_path_validate_read(path: str) -> tuple[safe.ProjectName, safe.VersionName, str | None]:
+ """Validate the path argument for rsync read commands, returning safe types."""
# READ: rsync --server --sender -vlogDtpre.iLsfxCIvu . /proj/v1/
# Validating path: /proj/v1/
- # WRITE: rsync --server -vlogDtpre.iLsfxCIvu . /proj/v1/
- # Validating path: /proj/v1/
-
- if not path.startswith("/"):
- raise RsyncArgsError("The path argument should be an absolute path")
-
- if not path.endswith("/"):
- # Technically we could ignore this, because we rewrite the path anyway for writes
- # But we should enforce good rsync usage practices
- raise RsyncArgsError("The path argument should be a directory path, ending with a /")
-
- if "//" in path:
- raise RsyncArgsError("The path argument should not contain //")
-
+ _validate_path_common(path)
if (path.count("/") < 3) or (path.count("/") > 4):
raise RsyncArgsError("The path argument should be a /PROJECT/VERSION/(tag)/ directory path")
path_project, path_version, *rest = path.strip("/").split("/", 2)
tag = rest[0] if rest else None
- alphanum = set(string.ascii_letters + string.digits + "-")
- if not all(c in alphanum for c in path_project):
- raise RsyncArgsError("The project name should contain only alphanumeric characters or hyphens")
-
- if tag and (not all(c in alphanum for c in tag)):
- raise RsyncArgsError("The tag should contain only alphanumeric characters or hyphens")
-
- # From a survey of version numbers we find that only . and - are used
- # We also allow + which is in common use
- version_punctuation = set(".-+")
- if path_version[0] not in alphanum:
- # Must certainly not allow the directory to be called "." or ".."
- # And we also want to avoid patterns like ".htaccess"
- raise RsyncArgsError("The version should start with an alphanumeric character")
- if path_version[-1] not in alphanum:
- raise RsyncArgsError("The version should end with an alphanumeric character")
- if not all(c in (alphanum | version_punctuation) for c in path_version):
- raise RsyncArgsError("The version should contain only alphanumeric characters, dots, dashes, or pluses")
+ _validate_project_segment(path_project)
+ _validate_version_segment(path_version)
+ if tag:
+ _validate_tag_segment(tag)
- return path_project, path_version, tag
+ project_name, version_name = await _validate_project_and_version(path_project, path_version)
+ if version_name is None:
+ raise RsyncArgsError(f"Release '{path_project}-{path_version}' does not exist")
+ return project_name, version_name, tag
-def _step_05b_command_path_validate_write(path: str) -> tuple[str, str, str | None]:
- """Validate the path argument for rsync commands."""
- # READ: rsync --server --sender -vlogDtpre.iLsfxCIvu . /proj/v1/
- # Validating path: /proj/v1/
+async def _step_05b_command_path_validate_write(path: str) -> tuple[safe.ProjectName, safe.VersionName, None]:
+ """Validate the path argument for rsync write commands, returning safe types."""
# WRITE: rsync --server -vlogDtpre.iLsfxCIvu . /proj/v1/
# Validating path: /proj/v1/
+ _validate_path_common(path)
+ if path.count("/") != 3:
+ raise RsyncArgsError("The path argument should be a /PROJECT/VERSION/ directory path")
+
+ path_project, path_version = path.strip("/").split("/", 1)
+ _validate_project_segment(path_project)
+ _validate_version_segment(path_version)
+ project_name, version_name = await _validate_project_and_version(path_project, path_version)
+ if version_name is None:
+ # No existing release: format-validated version accepted for new release creation
+ # TODO: AM Example where need to validate but not validate
+ version_name = safe.VersionName(path_version)
+ return project_name, version_name, None
+
+
+def _validate_path_common(path: str) -> None:
+ """Validate the common structural requirements for an rsync path argument."""
if not path.startswith("/"):
raise RsyncArgsError("The path argument should be an absolute path")
-
if not path.endswith("/"):
# Technically we could ignore this, because we rewrite the path anyway for writes
# But we should enforce good rsync usage practices
raise RsyncArgsError("The path argument should be a directory path, ending with a /")
-
if "//" in path:
raise RsyncArgsError("The path argument should not contain //")
- if path.count("/") != 3:
- raise RsyncArgsError("The path argument should be a /PROJECT/VERSION/ directory path")
- path_project, path_version = path.strip("/").split("/", 1)
- alphanum = set(string.ascii_letters + string.digits + "-")
- if not all(c in alphanum for c in path_project):
+def _validate_project_segment(segment: str) -> None:
+ if not all(c in _PATH_ALPHANUM for c in segment):
raise RsyncArgsError("The project name should contain only alphanumeric characters or hyphens")
- # From a survey of version numbers we find that only . and - are used
- # We also allow + which is in common use
- version_punctuation = set(".-+")
- if path_version[0] not in alphanum:
- # Must certainly not allow the directory to be called "." or ".."
- # And we also want to avoid patterns like ".htaccess"
+
+def _validate_tag_segment(segment: str) -> None:
+ if not all(c in _PATH_ALPHANUM for c in segment):
+ raise RsyncArgsError("The tag should contain only alphanumeric characters or hyphens")
+
+
+def _validate_version_segment(segment: str) -> None:
+ # Must certainly not allow the directory to be called "." or ".."
+ # And we also want to avoid patterns like ".htaccess"
+ if segment[0] not in _PATH_ALPHANUM:
raise RsyncArgsError("The version should start with an alphanumeric character")
- if path_version[-1] not in alphanum:
+ if segment[-1] not in _PATH_ALPHANUM:
raise RsyncArgsError("The version should end with an alphanumeric character")
- if not all(c in (alphanum | version_punctuation) for c in path_version):
+ if not all(c in _PATH_VERSION_CHARS for c in segment):
raise RsyncArgsError("The version should contain only alphanumeric characters, dots, dashes, or pluses")
- return path_project, path_version, None
-
async def _step_06a_validate_read_permissions(
ssh_uid: str,
project: sql.Project,
release: sql.Release | None,
- path_project: str,
- path_version: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
tag: str | None,
) -> tuple[sql.Release | None, list[str] | None]:
"""Validate permissions for a read request."""
if release is None:
- raise RsyncArgsError(f"Release '{path_project}-{path_version}' does not exist")
+ raise RsyncArgsError(f"Release '{project_name}-{version_name}' does not exist")
allowed_read_phases = {
sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT,
@@ -571,14 +563,14 @@ async def _step_07a_process_validated_rsync_read(
async def _step_07b_process_validated_rsync_write(
process: asyncssh.SSHServerProcess,
argv: list[str],
- project_name: str,
+ project_name: safe.ProjectName,
version_name: str,
server: SSHServer,
) -> None:
"""Handle a validated rsync write request."""
asf_uid = server._get_asf_uid(process)
exit_status = 0
- release_name = sql.release_name(project_name, version_name)
+ release_name = sql.release_name(str(project_name), version_name)
# Ensure the release object exists or is created
# This must happen before creating the revision directory
@@ -640,15 +632,15 @@ async def _step_07b_process_validated_rsync_write(
process.exit(exit_status)
-async def _step_07c_ensure_release_object_for_write(project_name: str, version_name: str) -> None:
+async def _step_07c_ensure_release_object_for_write(project_name: safe.ProjectName, version_name: str) -> None:
"""Ensure the release object exists or create it for a write operation."""
- release_name = sql.release_name(project_name, version_name)
+ release_name = sql.release_name(str(project_name), version_name)
async with db.session() as data:
- release = await data.release(name=sql.release_name(project_name, version_name), _committee=True).get()
+ release = await data.release(name=release_name, _committee=True).get()
if release is None:
- project = await data.project(name=project_name, status=sql.ProjectStatus.ACTIVE, _committee=True).demand(
- RuntimeError("Project not found after validation")
- )
+ project = await data.project(
+ name=str(project_name), status=sql.ProjectStatus.ACTIVE, _committee=True
+ ).demand(RuntimeError("Project not found after validation"))
if version_name_error := util.version_name_error(version_name):
# This should ideally be caught by path validation, but double check
raise RuntimeError(f'Invalid version name "{version_name}": {version_name_error}')
@@ -667,6 +659,22 @@ async def _step_07c_ensure_release_object_for_write(project_name: str, version_n
await data.commit()
+async def _validate_project_and_version(
+ path_project: str, path_version: str
+) -> tuple[safe.ProjectName, safe.VersionName | None]:
+ """Validate a project and optional version against the cache or database, returning safe types.
+
+ Returns (project_name, version_name) where version_name is None if no matching
+ release exists. The project must exist or RsyncArgsError is raised.
+ """
+ project_name = await safe.ProjectName.create(path_project)
+ if not project_name:
+ raise RsyncArgsError(f"Project '{path_project}' does not exist")
+
+ version_name = await safe.VersionName.create(path_version, project_name)
+ return project_name, version_name
+
+
async def _step_08_execute_rsync(process: asyncssh.SSHServerProcess, argv: list[str]) -> int:
"""Execute the modified rsync command."""
log.info(f"Executing modified rsync command: {' '.join(argv)}")
diff --git a/atr/storage/__init__.py b/atr/storage/__init__.py
index 4b8caa0f..f78f2601 100644
--- a/atr/storage/__init__.py
+++ b/atr/storage/__init__.py
@@ -29,6 +29,7 @@ if TYPE_CHECKING:
import atr.db as db
import atr.log as log
import atr.models.basic as basic
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.principal as principal
import atr.storage.outcome as outcome
@@ -332,12 +333,12 @@ class Write:
# async def as_key_owner(self) -> types.Outcome[WriteAsKeyOwner]:
# ...
- async def as_project_committee_admin(self, project_name: str) -> WriteAsCommitteeAdmin:
+ async def as_project_committee_admin(self, project_name: safe.ProjectName) -> WriteAsCommitteeAdmin:
write_as_outcome = await self.as_project_committee_admin_outcome(project_name)
return write_as_outcome.result_or_raise()
- async def as_project_committee_admin_outcome(self, project_name: str) -> outcome.Outcome[WriteAsCommitteeAdmin]:
- project = await self.__data.project(project_name, _committee=True).demand(
+ async def as_project_committee_admin_outcome(self, project_name: safe.ProjectName) -> outcome.Outcome[WriteAsCommitteeAdmin]:
+ project = await self.__data.project(str(project_name), _committee=True).demand(
AccessError(f"Project not found: {project_name}")
)
if project.committee is None:
@@ -356,8 +357,10 @@ class Write:
write_as_outcome = await self.as_project_committee_member_outcome(project_name)
return write_as_outcome.result_or_raise()
- async def as_project_committee_member_outcome(self, project_name: str) -> outcome.Outcome[WriteAsCommitteeMember]:
- project = await self.__data.project(project_name, _committee=True).demand(
+ async def as_project_committee_member_outcome(
+ self, project_name: safe.ProjectName
+ ) -> outcome.Outcome[WriteAsCommitteeMember]:
+ project = await self.__data.project(str(project_name), _committee=True).demand(
AccessError(f"Project not found: {project_name}")
)
if project.committee is None:
@@ -372,15 +375,15 @@ class Write:
return outcome.Error(e)
return outcome.Result(wacm)
- async def as_project_committee_participant(self, project_name: str) -> WriteAsCommitteeParticipant:
+ async def as_project_committee_participant(self, project_name: safe.ProjectName) -> WriteAsCommitteeParticipant:
write_as_outcome = await self.as_project_committee_participant_outcome(project_name)
return write_as_outcome.result_or_raise()
async def as_project_committee_participant_outcome(
- self, project_name: str
+ self, project_name: safe.ProjectName
) -> outcome.Outcome[WriteAsCommitteeParticipant]:
- project = await self.__data.project(project_name, _committee=True).demand(
- AccessError(f"Project not found: {project_name}")
+ project = await self.__data.project(str(project_name), _committee=True).demand(
+ AccessError(f"Project not found: {project_name!s}")
)
if project.committee is None:
return outcome.Error(AccessError("No committee found for project - Invalid state"))
@@ -509,7 +512,7 @@ async def write_as_committee_participant(
@contextlib.asynccontextmanager
async def write_as_project_committee_member(
- project_name: str,
+ project_name: safe.ProjectName,
asf_uid: principal.UID = principal.ArgumentNone,
) -> AsyncGenerator[WriteAsCommitteeMember]:
async with write(asf_uid) as w:
diff --git a/atr/storage/readers/checks.py b/atr/storage/readers/checks.py
index c5446ad6..466e2fc7 100644
--- a/atr/storage/readers/checks.py
+++ b/atr/storage/readers/checks.py
@@ -22,6 +22,7 @@ from typing import TYPE_CHECKING
import atr.db as db
import atr.db.interaction as interaction
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.storage as storage
import atr.storage.types as types
@@ -54,7 +55,7 @@ class GeneralPublic:
# Filter out any results that are ignored
unignored_checks = []
ignored_checks = []
- match_ignore = await self.ignores_matcher(release.project_name)
+ match_ignore = await self.ignores_matcher(release.safe_project_name)
for cr in all_check_results:
if not match_ignore(cr):
unignored_checks.append(cr)
@@ -78,18 +79,18 @@ class GeneralPublic:
member_results_list[member_rel_path].sort(key=lambda r: r.checker)
return types.CheckResults(primary_results_list, member_results_list, ignored_checks)
- async def ignores(self, project_name: str) -> list[sql.CheckResultIgnore]:
+ async def ignores(self, project_name: safe.ProjectName) -> list[sql.CheckResultIgnore]:
results = await self.__data.check_result_ignore(
- project_name=project_name,
+ project_name=str(project_name),
).all()
return list(results)
async def ignores_matcher(
self,
- project_name: str,
+ project_name: safe.ProjectName,
) -> Callable[[sql.CheckResult], bool]:
ignores = await self.__data.check_result_ignore(
- project_name=project_name,
+ project_name=str(project_name),
).all()
def match(cr: sql.CheckResult) -> bool:
@@ -110,7 +111,7 @@ class GeneralPublic:
# Blockers are never ignored
return False
if cri.release_glob is not None:
- if not self.__check_ignore_match_pattern(cri.release_glob, cr.release_name):
+ if not self.__check_ignore_match_pattern(cri.release_glob, str(cr.release_name)):
return False
if cri.revision_number is not None:
if cri.revision_number != cr.revision_number:
diff --git a/atr/storage/readers/releases.py b/atr/storage/readers/releases.py
index 77d330fb..cfbfca0e 100644
--- a/atr/storage/readers/releases.py
+++ b/atr/storage/readers/releases.py
@@ -123,7 +123,7 @@ class GeneralPublic:
async def __successes_errors_warnings(
self, release: sql.Release, latest_revision_number: str, info: types.PathInfo
) -> None:
- match_ignore = await self.__read_as.checks.ignores_matcher(release.project_name)
+ match_ignore = await self.__read_as.checks.ignores_matcher(release.safe_project_name)
attestable_checks = await interaction.checks_for(
release, revision=latest_revision_number, caller_data=self.__data
)
diff --git a/atr/storage/writers/announce.py b/atr/storage/writers/announce.py
index aa9b0a88..a56a2997 100644
--- a/atr/storage/writers/announce.py
+++ b/atr/storage/writers/announce.py
@@ -29,6 +29,7 @@ import sqlmodel
import atr.construct as construct
import atr.db as db
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.paths as paths
import atr.storage as storage
@@ -103,8 +104,8 @@ class CommitteeMember(CommitteeParticipant):
async def release( # noqa: C901
self,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
preview_revision_number: str,
recipient: str,
body: str,
@@ -120,8 +121,8 @@ class CommitteeMember(CommitteeParticipant):
finished_dir: str = ""
release = await self.__data.release(
- project_name=project_name,
- version=version_name,
+ project_name=str(project_name),
+ version=str(version_name),
phase=sql.ReleasePhase.RELEASE_PREVIEW,
latest_revision_number=preview_revision_number,
_project_release_policy=True,
@@ -196,8 +197,8 @@ class CommitteeMember(CommitteeParticipant):
await aioshutil.move(unfinished_dir, finished_dir)
self.__write_as.append_to_audit_log(
asf_uid=self.__asf_uid,
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
revision_number=preview_revision_number,
source_directory=unfinished_dir,
target_directory=finished_dir,
@@ -235,8 +236,8 @@ class CommitteeMember(CommitteeParticipant):
in_reply_to=None,
).model_dump(),
asf_uid=asf_uid,
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
)
self.__data.add(task)
diff --git a/atr/storage/writers/checks.py b/atr/storage/writers/checks.py
index 5b2dc0a6..8140dc28 100644
--- a/atr/storage/writers/checks.py
+++ b/atr/storage/writers/checks.py
@@ -23,6 +23,7 @@ import datetime
import sqlmodel
import atr.db as db
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.models.validation as validation
import atr.storage as storage
@@ -92,7 +93,7 @@ class CommitteeMember(CommitteeParticipant):
async def ignore_add(
self,
- project_name: str,
+ project_name: safe.ProjectName,
release_glob: str | None = None,
revision_number: str | None = None,
checker_glob: str | None = None,
@@ -101,7 +102,7 @@ class CommitteeMember(CommitteeParticipant):
status: sql.CheckResultStatusIgnore | None = None,
message_glob: str | None = None,
) -> None:
- await self.__validate_project_in_committee(project_name)
+ await self.__validate_project_in_committee(str(project_name))
_validate_ignore_patterns(
release_glob,
checker_glob,
@@ -112,7 +113,7 @@ class CommitteeMember(CommitteeParticipant):
cri = sql.CheckResultIgnore(
asf_uid=self.__asf_uid,
created=datetime.datetime.now(datetime.UTC),
- project_name=project_name,
+ project_name=str(project_name),
release_glob=release_glob,
revision_number=revision_number,
checker_glob=checker_glob,
diff --git a/atr/storage/writers/distributions.py b/atr/storage/writers/distributions.py
index 34a40c9b..98adfdea 100644
--- a/atr/storage/writers/distributions.py
+++ b/atr/storage/writers/distributions.py
@@ -94,12 +94,12 @@ class CommitteeMember(CommitteeParticipant):
async def automate(
self,
- release_name: str,
+ release_name: models.safe.ReleaseName,
platform: models.sql.DistributionPlatform,
committee_name: str,
owner_namespace: str | None,
- project_name: str,
- version_name: str,
+ project_name: models.safe.ProjectName,
+ version_name: models.safe.VersionName,
phase: str,
revision_number: str | None,
package: str,
@@ -109,7 +109,7 @@ class CommitteeMember(CommitteeParticipant):
dist_task = models.sql.Task(
task_type=models.sql.TaskType.DISTRIBUTION_WORKFLOW,
task_args=gha.DistributionWorkflow(
- name=release_name,
+ name=str(release_name),
namespace=owner_namespace or "",
package=package,
version=version,
@@ -125,8 +125,8 @@ class CommitteeMember(CommitteeParticipant):
asf_uid=util.unwrap(self.__asf_uid),
added=datetime.datetime.now(datetime.UTC),
status=models.sql.TaskStatus.QUEUED,
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
revision_number=revision_number,
)
self.__data.add(dist_task)
@@ -136,7 +136,7 @@ class CommitteeMember(CommitteeParticipant):
async def record(
self,
- release_name: str,
+ release_name: models.safe.ReleaseName,
platform: models.sql.DistributionPlatform,
owner_namespace: str | None,
package: str,
@@ -147,10 +147,12 @@ class CommitteeMember(CommitteeParticipant):
api_url: str | None = None,
web_url: str | None = None,
) -> tuple[models.sql.Distribution, bool]:
- existing = await self.__data.distribution(release_name, platform, owner_namespace or "", package, version).get()
+ existing = await self.__data.distribution(
+ str(release_name), platform, owner_namespace or "", package, version
+ ).get()
dist = models.sql.Distribution(
platform=platform,
- release_name=release_name,
+ release_name=str(release_name),
owner_namespace=owner_namespace or "",
package=package,
version=version,
@@ -194,7 +196,7 @@ class CommitteeMember(CommitteeParticipant):
async def record_from_data(
self,
- release_name: str,
+ release_name: models.safe.ReleaseName,
staging: bool,
dd: models.distribution.Data,
allow_retries: bool = False,
@@ -250,7 +252,7 @@ class CommitteeMember(CommitteeParticipant):
async def __upgrade_staging_to_final(
self,
- release_name: str,
+ release_name: models.safe.ReleaseName,
platform: models.sql.DistributionPlatform,
owner_namespace: str | None,
package: str,
@@ -262,7 +264,7 @@ class CommitteeMember(CommitteeParticipant):
) -> models.sql.Distribution | None:
tag = f"{release_name} {platform} {owner_namespace or ''} {package} {version}"
existing = await self.__data.distribution(
- release_name=release_name,
+ release_name=str(release_name),
platform=platform,
owner_namespace=(owner_namespace or ""),
package=package,
@@ -281,14 +283,14 @@ class CommitteeMember(CommitteeParticipant):
async def delete_distribution(
self,
- release_name: str,
+ release_name: models.safe.ReleaseName,
platform: models.sql.DistributionPlatform,
owner_namespace: str,
package: str,
version: str,
) -> None:
distribution = await self.__data.distribution(
- release_name=release_name,
+ release_name=str(release_name),
platform=platform,
owner_namespace=owner_namespace,
package=package,
diff --git a/atr/storage/writers/keys.py b/atr/storage/writers/keys.py
index b0cb6ee4..cfc07d5e 100644
--- a/atr/storage/writers/keys.py
+++ b/atr/storage/writers/keys.py
@@ -40,6 +40,7 @@ import sqlmodel
import atr.config as config
import atr.db as db
import atr.log as log
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.paths as paths
import atr.storage as storage
@@ -465,10 +466,12 @@ class CommitteeParticipant(FoundationCommitter):
await self.autogenerate_keys_file()
return outcomes
- async def import_keys_file(self, project_name: str, version_name: str) -> outcome.List[types.Key]:
+ async def import_keys_file(
+ self, project_name: safe.ProjectName, version_name: safe.VersionName
+ ) -> outcome.List[types.Key]:
release = await self.__data.release(
- project_name=project_name,
- version=version_name,
+ project_name=str(project_name),
+ version=str(version_name),
_committee=True,
).demand(storage.AccessError(f"Release not found: {project_name} {version_name}"))
keys_path = paths.release_directory(release) / "KEYS"
@@ -478,7 +481,7 @@ class CommitteeParticipant(FoundationCommitter):
raise storage.AccessError("No committee found for release - Invalid state")
if release.committee.name != self.__committee_name:
raise storage.AccessError(
- f"Release {project_name} {version_name} is not associated with committee {self.__committee_name}"
+ f"Release {project_name!s} {version_name!s} is not associated with committee {self.__committee_name}"
)
outcomes = await self.ensure_associated(keys_file_text)
diff --git a/atr/storage/writers/policy.py b/atr/storage/writers/policy.py
index a6ff2760..79f0f6f8 100644
--- a/atr/storage/writers/policy.py
+++ b/atr/storage/writers/policy.py
@@ -129,7 +129,7 @@ class CommitteeMember(CommitteeParticipant):
release_policy.file_tag_mappings = atr_tags_dict
release_policy.strict_checking = form.strict_checking
- await self.__commit_and_log(project_name)
+ await self.__commit_and_log(str(project_name))
async def edit_finish(self, form: shared.projects.FinishPolicyForm) -> None:
project_name = form.project_name
@@ -140,7 +140,7 @@ class CommitteeMember(CommitteeParticipant):
self.__set_announce_release_template(form.announce_release_template or "", project, release_policy)
release_policy.preserve_download_files = form.preserve_download_files
- await self.__commit_and_log(project_name)
+ await self.__commit_and_log(str(project_name))
async def edit_vote(self, form: shared.projects.VotePolicyForm) -> None:
project_name = form.project_name
@@ -160,7 +160,7 @@ class CommitteeMember(CommitteeParticipant):
elif project.committee and project.committee.is_podling:
raise storage.AccessError("Manual voting is not allowed for podlings.")
- await self.__commit_and_log(project_name)
+ await self.__commit_and_log(str(str(project_name)))
async def __commit_and_log(self, project_name: str) -> None:
await self.__data.commit()
@@ -169,9 +169,11 @@ class CommitteeMember(CommitteeParticipant):
project_name=project_name,
)
- async def __get_or_create_policy(self, project_name: str) -> tuple[models.sql.Project, models.sql.ReleasePolicy]:
+ async def __get_or_create_policy(
+ self, project_name: models.safe.ProjectName
+ ) -> tuple[models.sql.Project, models.sql.ReleasePolicy]:
project = await self.__data.project(
- name=project_name, status=models.sql.ProjectStatus.ACTIVE, _release_policy=True, _committee=True
+ name=str(project_name), status=models.sql.ProjectStatus.ACTIVE, _release_policy=True, _committee=True
).demand(storage.AccessError(f"Project {project_name} not found"))
release_policy = project.release_policy
diff --git a/atr/storage/writers/project.py b/atr/storage/writers/project.py
index 69a3b8ce..0580a2bc 100644
--- a/atr/storage/writers/project.py
+++ b/atr/storage/writers/project.py
@@ -21,6 +21,7 @@ from __future__ import annotations
import datetime
import atr.db as db
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.registry as registry
import atr.storage as storage
@@ -106,7 +107,7 @@ class CommitteeMember(CommitteeParticipant):
await self.__data.commit()
self.__write_as.append_to_audit_log(
asf_uid=self.__asf_uid,
- project_name=project.name,
+ project_name=str(project.name),
category=new_category,
)
return True
@@ -125,7 +126,7 @@ class CommitteeMember(CommitteeParticipant):
await self.__data.commit()
self.__write_as.append_to_audit_log(
asf_uid=self.__asf_uid,
- project_name=project.name,
+ project_name=str(project.name),
category=action_value,
)
return True
@@ -133,6 +134,8 @@ class CommitteeMember(CommitteeParticipant):
async def create(self, committee_name: str, display_name: str, label: str) -> None:
super_project = None
+ # Wrap the name in safe.ProjectName so we can create it in the database
+ # TODO: Do we need to do any additional validation on the string value?
# Get the base project to derive from
# We're allowing derivation from a retired project here
# TODO: Should we disallow this instead?
@@ -140,8 +143,8 @@ class CommitteeMember(CommitteeParticipant):
committee_name=committee_name, _committee=True, _release_policy=True
).all()
for committee_project in committee_projects:
- if label.startswith(committee_project.name + "-"):
- if (super_project is None) or (len(super_project.name) < len(committee_project.name)):
+ if label.startswith(str(committee_project.name) + "-"):
+ if (super_project is None) or (len(str(super_project.name)) < len(str(committee_project.name))):
super_project = committee_project
# Check whether the project already exists
@@ -173,9 +176,9 @@ class CommitteeMember(CommitteeParticipant):
project_name=label,
)
- async def delete(self, project_name: str) -> None:
+ async def delete(self, project_name: safe.ProjectName) -> None:
project = await self.__data.project(
- name=project_name, status=sql.ProjectStatus.ACTIVE, _releases=True, _distribution_channels=True
+ name=str(project_name), status=sql.ProjectStatus.ACTIVE, _releases=True, _distribution_channels=True
).get()
if not project:
@@ -197,7 +200,7 @@ class CommitteeMember(CommitteeParticipant):
await self.__data.commit()
self.__write_as.append_to_audit_log(
asf_uid=self.__asf_uid,
- project_name=project_name,
+ project_name=str(project_name),
)
return None
@@ -216,7 +219,7 @@ class CommitteeMember(CommitteeParticipant):
await self.__data.commit()
self.__write_as.append_to_audit_log(
asf_uid=self.__asf_uid,
- project_name=project.name,
+ project_name=str(project.name),
language=new_language,
)
return True
@@ -233,7 +236,7 @@ class CommitteeMember(CommitteeParticipant):
await self.__data.commit()
self.__write_as.append_to_audit_log(
asf_uid=self.__asf_uid,
- project_name=project.name,
+ project_name=str(project.name),
language=action_value,
)
return True
diff --git a/atr/storage/writers/release.py b/atr/storage/writers/release.py
index 10188b5f..37ba75fc 100644
--- a/atr/storage/writers/release.py
+++ b/atr/storage/writers/release.py
@@ -35,6 +35,7 @@ import atr.db as db
import atr.form as form
import atr.log as log
import atr.models.api as api
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.paths as paths
import atr.storage as storage
@@ -95,24 +96,24 @@ class CommitteeParticipant(FoundationCommitter):
async def delete(
self,
- project_name: str,
- version: str,
+ project_name: safe.ProjectName,
+ version: safe.VersionName,
phase: db.Opt[sql.ReleasePhase] = db.NOT_SET,
include_downloads: bool = True,
) -> str | None:
"""Handle the deletion of database records and filesystem data for a release."""
release = await self.__data.release(
- project_name=project_name, version=version, phase=phase, _committee=True
- ).demand(storage.AccessError(f"Release '{project_name} {version}' not found."))
+ project_name=str(project_name), version=str(version), phase=phase, _committee=True
+ ).demand(storage.AccessError(f"Release '{project_name!s} {version!s}' not found."))
release_dirs = [
paths.release_directory_base(release),
- paths.get_attestable_dir() / project_name / version,
- paths.get_cache_archives_dir() / project_name / version,
- paths.get_quarantined_dir() / project_name / version,
+ paths.get_attestable_dir() / str(project_name) / str(version),
+ paths.get_cache_archives_dir() / str(project_name) / str(version),
+ paths.get_quarantined_dir() / str(project_name) / str(version),
]
# Delete from the database using bulk SQL DELETE for efficiency
- log.info(f"Deleting database records for release: {project_name} {version}")
+ log.info(f"Deleting database records for release: {project_name!s} {version!s}")
# Bulk delete tasks
# These is no cascade, so we must delete explicitly
@@ -123,11 +124,11 @@ class CommitteeParticipant(FoundationCommitter):
)
task_result = await self.__data.execute(task_delete_stmt)
task_count = task_result.rowcount if isinstance(task_result, engine.CursorResult) else 0
- log.debug(f"Deleted {util.plural(task_count, 'task')} for {project_name} {version}")
+ log.debug(f"Deleted {util.plural(task_count, 'task')} for {project_name!s} {version!s}")
release_name = release.name
await self.__data.delete(release)
- log.info(f"Deleted release record: {project_name} {version}")
+ log.info(f"Deleted release record: {project_name!s} {version!s}")
# In test mode, delete the counter for test committee releases
# This allows revision numbers to be reused in testing
@@ -150,14 +151,14 @@ class CommitteeParticipant(FoundationCommitter):
self.__write_as.append_to_audit_log(
asf_uid=self.__asf_uid,
- project_name=project_name,
- version=version,
+ project_name=str(project_name),
+ version=str(version),
error=error,
)
return error
async def delete_empty_directory(
- self, project_name: str, version_name: str, dir_to_delete_rel: pathlib.Path
+ self, project_name: safe.ProjectName, version_name: safe.VersionName, dir_to_delete_rel: pathlib.Path
) -> str | None:
description = f"Delete empty directory {dir_to_delete_rel} via web interface"
@@ -179,7 +180,9 @@ class CommitteeParticipant(FoundationCommitter):
return str(e)
return None
- async def delete_file(self, project_name: str, version: str, rel_path_to_delete: pathlib.Path) -> int:
+ async def delete_file(
+ self, project_name: safe.ProjectName, version: safe.VersionName, rel_path_to_delete: pathlib.Path
+ ) -> int:
metadata_files_deleted = 0
description = "File deletion through web interface"
@@ -217,7 +220,9 @@ class CommitteeParticipant(FoundationCommitter):
)
return metadata_files_deleted
- async def generate_hash_file(self, project_name: str, version_name: str, rel_path: pathlib.Path) -> None:
+ async def generate_hash_file(
+ self, project_name: safe.ProjectName, version_name: safe.VersionName, rel_path: pathlib.Path
+ ) -> None:
description = "Hash generation through web interface"
async def modify(path: pathlib.Path, _old_rev: sql.Revision | None) -> None:
@@ -256,7 +261,12 @@ class CommitteeParticipant(FoundationCommitter):
)
async def import_from_svn(
- self, project_name: str, version_name: str, svn_url: str, revision: str, target_subdirectory: str | None
+ self,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
+ svn_url: str,
+ revision: str,
+ target_subdirectory: str | None,
) -> sql.Task:
task_args = {
"svn_url": svn_url,
@@ -272,8 +282,8 @@ class CommitteeParticipant(FoundationCommitter):
asf_uid=util.unwrap(self.__asf_uid),
added=datetime.datetime.now(datetime.UTC),
status=sql.TaskStatus.QUEUED,
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
)
self.__data.add(svn_import_task)
await self.__data.commit()
@@ -281,7 +291,11 @@ class CommitteeParticipant(FoundationCommitter):
return svn_import_task
async def move_file(
- self, project_name: str, version_name: str, source_files_rel: list[pathlib.Path], target_dir_rel: pathlib.Path
+ self,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
+ source_files_rel: list[pathlib.Path],
+ target_dir_rel: pathlib.Path,
) -> tuple[str | None, list[str], list[str]]:
description = "File move through web interface"
moved_files_names: list[str] = []
@@ -306,16 +320,16 @@ class CommitteeParticipant(FoundationCommitter):
async def promote_to_candidate(
self,
- release_name: str,
+ release_name: safe.ReleaseName,
selected_revision_number: str,
vote_manual: bool = False,
) -> str | None:
"""Promote a release candidate draft to a new phase."""
- release_for_pre_checks = await self.__data.release(name=release_name, _project=True).demand(
+ release_for_pre_checks = await self.__data.release(name=str(release_name), _project=True).demand(
storage.AccessError("Release candidate draft not found")
)
- project_name = release_for_pre_checks.project.name
- version_name = release_for_pre_checks.version
+ project_name = release_for_pre_checks.safe_project_name
+ version_name = release_for_pre_checks.safe_version_name
# Check for ongoing tasks
ongoing_tasks = await self.__tasks_ongoing(project_name, version_name, selected_revision_number)
@@ -362,13 +376,15 @@ class CommitteeParticipant(FoundationCommitter):
await self.__data.commit()
self.__write_as.append_to_audit_log(
asf_uid=self.__asf_uid,
- release_name=release_name,
+ release_name=str(release_name),
selected_revision_number=selected_revision_number,
vote_manual=vote_manual,
)
return None
- async def remove_rc_tags(self, project_name: str, version_name: str) -> tuple[str | None, int, list[str]]:
+ async def remove_rc_tags(
+ self, project_name: safe.ProjectName, version_name: safe.VersionName
+ ) -> tuple[str | None, int, list[str]]:
description = "Remove RC tags from paths via web interface"
error_messages: list[str] = []
renamed_count = 0
@@ -385,10 +401,13 @@ class CommitteeParticipant(FoundationCommitter):
return str(e), renamed_count, error_messages
return None, renamed_count, error_messages
- async def start(self, project_name: str, version: str) -> tuple[sql.Release, sql.Project]: # noqa: C901
+ async def start(self, project_name: safe.ProjectName, version: str) -> tuple[sql.Release, sql.Project]: # noqa: C901
"""Creates the initial release draft record and revision directory."""
# Get the project from the project name
- project = await self.__data.project(name=project_name, status=sql.ProjectStatus.ACTIVE, _committee=True).get()
+ project = await self.__data.project(
+ name=str(project_name), status=sql.ProjectStatus.ACTIVE, _committee=True
+ ).get()
+ version_name = safe.VersionName(version)
if not project:
raise storage.AccessError(f"Project {project_name} not found")
@@ -415,7 +434,7 @@ class CommitteeParticipant(FoundationCommitter):
# TODO: Consider using Release.revision instead of ./latest
# Check whether the release already exists
- if release := await self.__data.release(project_name=project.name, version=version).get():
+ if release := await self.__data.release(project_name=project.name, version=str(version_name)).get():
match release.phase:
case sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT:
phase_desc = "A draft release (being composed)"
@@ -425,19 +444,18 @@ class CommitteeParticipant(FoundationCommitter):
phase_desc = "A release preview (being finished)"
case sql.ReleasePhase.RELEASE:
phase_desc = "A finished release"
- raise storage.AccessError(f"{phase_desc} for {project_name} {version} already exists.")
+ raise storage.AccessError(f"{phase_desc} for {project_name!s} {version} already exists.")
# Validate the version name
# TODO: We should check that it's bigger than the current version
# We have the packaging library as a dependency, but it is Python specific
if version_name_error := util.version_name_error(version):
- raise storage.AccessError(f'Invalid version name "{version}": {version_name_error}')
-
+ raise storage.AccessError(f'Invalid version name "{version!s}": {version_name_error}')
release = sql.Release(
phase=sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT,
project_name=project.name,
project=project,
- version=version,
+ version=str(version_name),
created=datetime.datetime.now(datetime.UTC),
)
self.__data.add(release)
@@ -450,8 +468,8 @@ class CommitteeParticipant(FoundationCommitter):
)
self.__write_as.append_to_audit_log(
asf_uid=self.__asf_uid,
- project_name=project_name,
- version=version,
+ project_name=project.name,
+ version=str(version),
created=release.created.isoformat(),
)
return release, project
@@ -479,14 +497,14 @@ class CommitteeParticipant(FoundationCommitter):
async with db.session() as data:
release_name = sql.release_name(args.project, args.version)
return await data.revision(
- release_name=release_name,
+ release_name=str(release_name),
number=result.number,
).demand(storage.AccessError("Revision not found"))
async def upload_files(
self,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
file_name: pathlib.Path | None,
files: Sequence[datastructures.FileStorage],
) -> tuple[str | None, int, bool]:
@@ -558,7 +576,7 @@ class CommitteeParticipant(FoundationCommitter):
continue
async def __delete_release_data_filesystem(
- self, release_dirs: Sequence[pathlib.Path], project_name: str, version: str
+ self, release_dirs: Sequence[pathlib.Path], project_name: safe.ProjectName, version: safe.VersionName
) -> str | None:
delete_errors: list[str] = []
for release_dir in release_dirs:
@@ -566,7 +584,7 @@ class CommitteeParticipant(FoundationCommitter):
try:
log.info(f"Deleting filesystem directory: {release_dir}")
await util.delete_immutable_directory(
- release_dir, reason=f"user {self.__asf_uid} is deleting release {project_name} {version}"
+ release_dir, reason=f"user {self.__asf_uid} is deleting release {project_name!s} {version!s}"
)
log.info(f"Successfully deleted directory: {release_dir}")
except Exception as e:
@@ -576,7 +594,7 @@ class CommitteeParticipant(FoundationCommitter):
log.warning(f"Filesystem directory not found, skipping deletion: {release_dir}")
if delete_errors:
return (
- f"Database records for '{project_name} {version}' deleted,"
+ f"Database records for '{project_name!s} {version!s}' deleted,"
f" but failed to delete filesystem directories: {', '.join(delete_errors)}"
)
return None
@@ -747,7 +765,9 @@ class CommitteeParticipant(FoundationCommitter):
if f == source_file_rel:
moved_files_names.append(f.name)
- async def __tasks_ongoing(self, project_name: str, version_name: str, revision_number: str | None = None) -> int:
+ async def __tasks_ongoing(
+ self, project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str | None = None
+ ) -> int:
tasks = sqlmodel.select(sqlalchemy.func.count()).select_from(sql.Task)
query = tasks.where(
sql.Task.project_name == project_name,
diff --git a/atr/storage/writers/revision.py b/atr/storage/writers/revision.py
index e3bcde32..1255ebde 100644
--- a/atr/storage/writers/revision.py
+++ b/atr/storage/writers/revision.py
@@ -35,6 +35,7 @@ import atr.db as db
import atr.db.interaction as interaction
import atr.detection as detection
import atr.merge as merge
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.paths as paths
import atr.storage as storage
@@ -82,12 +83,12 @@ async def finalise_revision(
path_to_hash: dict[str, str],
path_to_size: dict[str, int],
previous_attestable: atr.models.attestable.AttestableV1 | None,
- project_name: str,
+ project_name: safe.ProjectName,
release: sql.Release,
- release_name: str,
+ release_name: safe.ReleaseName,
temp_dir: str,
temp_dir_path: pathlib.Path,
- version_name: str,
+ version_name: safe.VersionName,
was_quarantined: bool = False,
) -> sql.Revision:
try:
@@ -120,7 +121,7 @@ async def finalise_revision(
previous_attestable=previous_attestable,
project_name=project_name,
release=merged_release,
- release_name=release_name,
+ release_name=str(release_name),
temp_dir=temp_dir,
version_name=version_name,
was_quarantined=was_quarantined,
@@ -135,11 +136,11 @@ async def _commit_new_revision(
path_to_hash: dict[str, str],
path_to_size: dict[str, int],
previous_attestable: atr.models.attestable.AttestableV1 | None,
- project_name: str,
+ project_name: safe.ProjectName,
release: sql.Release,
release_name: str,
temp_dir: str,
- version_name: str,
+ version_name: safe.VersionName,
was_quarantined: bool = False,
) -> sql.Revision:
try:
@@ -238,11 +239,11 @@ async def _lock_and_merge(
path_to_hash: dict[str, str],
path_to_size: dict[str, int],
previous_attestable: atr.models.attestable.AttestableV1 | None,
- project_name: str,
+ project_name: safe.ProjectName,
release: sql.Release,
- _release_name: str,
+ _release_name: safe.ReleaseName,
temp_dir_path: pathlib.Path,
- version_name: str,
+ version_name: safe.VersionName,
) -> tuple[atr.models.attestable.AttestableV1 | None, str | None, sql.Release]:
# Acquire the write lock
# We need this write lock for moving the directory afterwards atomically
@@ -325,8 +326,8 @@ class CommitteeParticipant(FoundationCommitter):
async def create_revision_with_quarantine( # noqa: C901
self,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
asf_uid: str,
description: str | None = None,
set_local_cache: bool = False,
@@ -335,7 +336,7 @@ class CommitteeParticipant(FoundationCommitter):
clone_from: str | None = None,
) -> sql.Revision | sql.Quarantined:
"""Create a new revision, quarantining archives that require validation."""
- release_name = sql.release_name(project_name, version_name)
+ release_name = sql.release_name(str(project_name), str(version_name))
async with db.session() as data:
release = await data.release(name=release_name, _release_policy=True, _project_release_policy=True).demand(
RuntimeError("Release does not exist for new revision creation")
@@ -417,6 +418,7 @@ class CommitteeParticipant(FoundationCommitter):
async with SafeSession(temp_dir) as data:
try:
+ # TODO: Do we really need _release_name when we have release in this method?
previous_attestable, prior_revision_name, merged_release = await _lock_and_merge(
data,
base_hashes=base_hashes,
@@ -429,7 +431,7 @@ class CommitteeParticipant(FoundationCommitter):
previous_attestable=previous_attestable,
project_name=project_name,
release=release,
- _release_name=release_name,
+ _release_name=release.safe_name,
temp_dir_path=temp_dir_path,
version_name=version_name,
)
@@ -477,10 +479,10 @@ class CommitteeParticipant(FoundationCommitter):
description: str | None,
path_to_size: dict[str, int],
prior_revision_name: str | None,
- project_name: str,
+ project_name: safe.ProjectName,
release_name: str,
temp_dir: str,
- version_name: str,
+ version_name: safe.VersionName,
) -> sql.Quarantined:
file_metadata = [
sql.QuarantineFileEntryV1(
@@ -529,8 +531,8 @@ class CommitteeParticipant(FoundationCommitter):
],
},
asf_uid=asf_uid,
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
revision_number=None,
primary_rel_path=None,
)
diff --git a/atr/storage/writers/sbom.py b/atr/storage/writers/sbom.py
index b68a6cc9..aa88c42f 100644
--- a/atr/storage/writers/sbom.py
+++ b/atr/storage/writers/sbom.py
@@ -23,6 +23,7 @@ import datetime
from typing import TYPE_CHECKING
import atr.db as db
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.storage as storage
import atr.tasks.sbom as sbom
@@ -77,8 +78,8 @@ class CommitteeParticipant(FoundationCommitter):
async def augment_cyclonedx(
self,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
revision_number: str,
rel_path: pathlib.Path,
) -> sql.Task:
@@ -94,8 +95,8 @@ class CommitteeParticipant(FoundationCommitter):
asf_uid=util.unwrap(self.__asf_uid),
added=datetime.datetime.now(datetime.UTC),
status=sql.TaskStatus.QUEUED,
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
revision_number=revision_number,
primary_rel_path=str(rel_path),
)
@@ -106,8 +107,8 @@ class CommitteeParticipant(FoundationCommitter):
async def generate_cyclonedx(
self,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
revision_number: str,
path_in_new_revision: pathlib.Path,
sbom_path_in_new_revision: pathlib.Path,
@@ -125,8 +126,8 @@ class CommitteeParticipant(FoundationCommitter):
asf_uid=util.unwrap(self.__asf_uid),
added=datetime.datetime.now(datetime.UTC),
status=sql.TaskStatus.QUEUED,
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
revision_number=revision_number,
)
self.__data.add(sbom_task)
@@ -136,8 +137,8 @@ class CommitteeParticipant(FoundationCommitter):
async def osv_scan_cyclonedx(
self,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
revision_number: str,
rel_path: pathlib.Path,
) -> sql.Task:
@@ -153,8 +154,8 @@ class CommitteeParticipant(FoundationCommitter):
asf_uid=util.unwrap(self.__asf_uid),
added=datetime.datetime.now(datetime.UTC),
status=sql.TaskStatus.QUEUED,
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
revision_number=revision_number,
primary_rel_path=str(rel_path),
)
diff --git a/atr/storage/writers/ssh.py b/atr/storage/writers/ssh.py
index 555a173c..f122597e 100644
--- a/atr/storage/writers/ssh.py
+++ b/atr/storage/writers/ssh.py
@@ -22,6 +22,7 @@ import time
from typing import Any
import atr.db as db
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.storage as storage
import atr.util as util
@@ -85,7 +86,7 @@ class CommitteeParticipant(FoundationCommitter):
self.__committee_name = committee_name
async def add_workflow_key(
- self, github_uid: str, github_nid: int, project_name: str, key: str, github_payload: dict[str, Any]
+ self, github_uid: str, github_nid: int, project_name: safe.ProjectName, key: str, github_payload: dict[str, Any]
) -> tuple[str, int]:
now = int(time.time())
# Twenty minutes to upload all files
@@ -95,7 +96,7 @@ class CommitteeParticipant(FoundationCommitter):
wsk = sql.WorkflowSSHKey(
fingerprint=fingerprint,
key=key,
- project_name=project_name,
+ project_name=str(project_name),
asf_uid=self.__asf_uid,
github_uid=github_uid,
github_nid=github_nid,
@@ -107,7 +108,7 @@ class CommitteeParticipant(FoundationCommitter):
self.__write_as.append_to_audit_log(
asf_uid=self.__asf_uid,
fingerprint=fingerprint,
- project_name=project_name,
+ project_name=str(project_name),
github_uid=github_uid,
github_nid=github_nid,
expires=expires,
diff --git a/atr/storage/writers/vote.py b/atr/storage/writers/vote.py
index d8925418..fd02efbb 100644
--- a/atr/storage/writers/vote.py
+++ b/atr/storage/writers/vote.py
@@ -26,6 +26,7 @@ import atr.db as db
import atr.db.interaction as interaction
import atr.log as log
import atr.models.results as results
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.storage as storage
import atr.tasks.message as message
@@ -136,8 +137,8 @@ class CommitteeParticipant(FoundationCommitter):
async def start(
self,
email_to: str,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
selected_revision_number: str,
vote_duration_choice: int,
subject: str,
@@ -150,8 +151,8 @@ class CommitteeParticipant(FoundationCommitter):
) -> sql.Task:
if release is None:
release = await self.__data.release(
- project_name=project_name,
- version=version_name,
+ project_name=str(project_name),
+ version=str(version_name),
_project=True,
_committee=True,
).demand(storage.AccessError("Release not found"))
@@ -170,7 +171,7 @@ class CommitteeParticipant(FoundationCommitter):
if promote is True:
# This verifies the state and sets the phase to RELEASE_CANDIDATE
error = await self.__write_as.release.promote_to_candidate(
- release.name, selected_revision_number, vote_manual=False
+ release.safe_name, selected_revision_number, vote_manual=False
)
if error:
raise storage.AccessError(error)
@@ -187,7 +188,7 @@ class CommitteeParticipant(FoundationCommitter):
status=sql.TaskStatus.QUEUED,
task_type=sql.TaskType.VOTE_INITIATE,
task_args=tasks_vote.Initiate(
- release_name=release.name,
+ release_name=release.safe_name,
email_to=email_to,
vote_duration=vote_duration_choice,
initiator_id=asf_uid,
@@ -196,8 +197,8 @@ class CommitteeParticipant(FoundationCommitter):
body=body_data,
).model_dump(),
asf_uid=asf_uid,
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
)
self.__data.add(task)
await self.__data.commit()
@@ -228,14 +229,14 @@ class CommitteeMember(CommitteeParticipant):
async def resolve(
self,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
vote_result: Literal["passed", "failed"],
asf_fullname: str,
resolution_body: str,
) -> tuple[sql.Release, int | None, str, str | None]:
release = await self.__data.release(
- name=sql.release_name(project_name, version_name),
+ name=sql.release_name(str(project_name), str(version_name)),
phase=sql.ReleasePhase.RELEASE_CANDIDATE,
_project=True,
_committee=True,
@@ -268,12 +269,12 @@ class CommitteeMember(CommitteeParticipant):
async def resolve_manually(
self,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
vote_result: Literal["passed", "failed"],
) -> str:
release = await self.__data.release(
- name=sql.release_name(project_name, version_name),
+ name=sql.release_name(str(project_name), str(version_name)),
phase=sql.ReleasePhase.RELEASE_CANDIDATE,
_project=True,
_committee=True,
@@ -297,7 +298,7 @@ class CommitteeMember(CommitteeParticipant):
description = "Create a preview revision from the last candidate draft"
await self.__write_as.revision.create_revision_with_quarantine(
- project_name, release.version, self.__asf_uid, description=description
+ project_name, release.safe_version_name, self.__asf_uid, description=description
)
else:
release.phase = sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
@@ -309,15 +310,15 @@ class CommitteeMember(CommitteeParticipant):
self.__write_as.append_to_audit_log(
asf_uid=self.__asf_uid,
- project_name=project_name,
- version_name=version_name,
+ project_name=str(project_name),
+ version_name=str(version_name),
vote_result=vote_result,
)
return success_message
async def resolve_release(
self,
- project_name: str,
+ project_name: safe.ProjectName,
release: sql.Release,
voting_round: int | None,
vote_result: Literal["passed", "failed"],
@@ -350,13 +351,13 @@ class CommitteeMember(CommitteeParticipant):
if revision_number is None:
raise ValueError("Release has no revision number - Invalid state")
vote_duration = latest_vote_task.task_args["vote_duration"]
- subject_template = await construct.start_vote_subject_default(release.project.name)
- body_template = await construct.start_vote_default(release.project.name)
+ subject_template = await construct.start_vote_subject_default(release.safe_project_name)
+ body_template = await construct.start_vote_default(release.safe_project_name)
options = construct.StartVoteOptions(
asfuid=self.__asf_uid,
fullname=asf_fullname,
- project_name=release.project.name,
- version_name=release.version,
+ project_name=release.safe_project_name,
+ version_name=release.safe_version_name,
revision_number=revision_number,
vote_duration=vote_duration,
)
@@ -366,8 +367,8 @@ class CommitteeMember(CommitteeParticipant):
await self.start(
email_to=incubator_vote_address,
permitted_recipients=[incubator_vote_address],
- project_name=release.project.name,
- version_name=release.version,
+ project_name=release.safe_project_name,
+ version_name=release.safe_version_name,
selected_revision_number=revision_number,
asf_uid=self.__asf_uid,
asf_fullname=asf_fullname,
@@ -387,7 +388,7 @@ class CommitteeMember(CommitteeParticipant):
description = "Create a preview revision from the last candidate draft"
await self.__write_as.revision.create_revision_with_quarantine(
- project_name, release.version, self.__asf_uid, description=description
+ project_name, release.safe_version_name, self.__asf_uid, description=description
)
if (voting_round == 2) and (release.podling_thread_id is not None):
round_one_email_address, round_one_message_id = await util.email_mid_from_thread_id(
@@ -414,8 +415,8 @@ class CommitteeMember(CommitteeParticipant):
# TODO: Could move this up before send_resolution
self.__write_as.append_to_audit_log(
asf_uid=self.__asf_uid,
- project_name=project_name,
- version_name=release.version,
+ project_name=str(project_name),
+ version_name=str(release.version),
vote_result=vote_result,
voting_round=voting_round,
)
diff --git a/atr/storage/writers/workflowstatus.py b/atr/storage/writers/workflowstatus.py
index f944c796..1730afe0 100644
--- a/atr/storage/writers/workflowstatus.py
+++ b/atr/storage/writers/workflowstatus.py
@@ -19,6 +19,7 @@
from __future__ import annotations
import atr.db as db
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.storage as storage
@@ -103,7 +104,7 @@ class CommitteeMember(CommitteeParticipant):
self,
workflow_id: str,
run_id: int,
- project_name: str,
+ project_name: safe.ProjectName,
task_id: int | None = None,
status: str | None = None,
message: str | None = None,
@@ -116,7 +117,7 @@ class CommitteeMember(CommitteeParticipant):
ws = sql.WorkflowStatus(
workflow_id=workflow_id,
run_id=run_id,
- project_name=project_name,
+ project_name=str(project_name),
task_id=task_id,
status=status or "",
message=message,
@@ -126,7 +127,7 @@ class CommitteeMember(CommitteeParticipant):
self.__write_as.append_to_audit_log(
workflow_id=workflow_id,
run_id=run_id,
- project_name=project_name,
+ project_name=str(project_name),
task_id=task_id,
status=status,
message=message,
diff --git a/atr/tasks/__init__.py b/atr/tasks/__init__.py
index b79b8017..a4ffe630 100644
--- a/atr/tasks/__init__.py
+++ b/atr/tasks/__init__.py
@@ -29,6 +29,7 @@ import atr.attestable as attestable
import atr.db as db
import atr.hashes as hashes
import atr.models.results as results
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.paths as file_paths
import atr.tasks.checks as checks
@@ -131,32 +132,36 @@ async def distribution_status_check(
async def draft_checks(
- asf_uid: str, project_name: str, release_version: str, revision_number: str, caller_data: db.Session | None = None
+ asf_uid: str,
+ project_name: safe.ProjectName,
+ release_version: safe.VersionName,
+ revision_number: str,
+ caller_data: db.Session | None = None,
) -> int:
"""Core logic to analyse a draft revision and queue checks."""
# Construct path to the specific revision
# We don't have the release object here, so we can't use util.release_directory
- revision_path = file_paths.get_unfinished_dir() / project_name / release_version / revision_number
+ revision_path = file_paths.get_unfinished_dir() / str(project_name) / str(release_version) / revision_number
relative_paths = [path async for path in util.paths_recursive(revision_path)]
async with db.ensure_session(caller_data) as data:
release = await data.release(
- name=sql.release_name(project_name, release_version),
+ name=sql.release_name(str(project_name), str(release_version)),
_committee=True,
_release_policy=True,
_project_release_policy=True,
).demand(RuntimeError("Release not found"))
other_releases = (
- await data.release(project_name=project_name, phase=sql.ReleasePhase.RELEASE)
+ await data.release(project_name=str(project_name), phase=sql.ReleasePhase.RELEASE)
.order_by(sql.Release.released)
.all()
)
release_versions = sorted(
- [v for v in other_releases], key=lambda v: util.version_sort_key(v.version), reverse=True
+ [v for v in other_releases], key=lambda v: util.version_sort_key(str(v.version)), reverse=True
)
- release_version_sortable = util.version_sort_key(release_version)
+ release_version_sortable = util.version_sort_key(str(release_version))
previous_version = next(
- (v for v in release_versions if util.version_sort_key(v.version) < release_version_sortable), None
+ (v for v in release_versions if util.version_sort_key(str(v.version)) < release_version_sortable), None
)
for path in relative_paths:
await _draft_file_checks(
@@ -200,7 +205,11 @@ async def draft_checks(
async def keys_import_file(
- asf_uid: str, project_name: str, version_name: str, revision_number: str, caller_data: db.Session | None = None
+ asf_uid: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
+ revision_number: str,
+ caller_data: db.Session | None = None,
) -> None:
"""Import a KEYS file from a draft release candidate revision."""
async with db.ensure_session(caller_data) as data:
@@ -216,6 +225,8 @@ async def keys_import_file(
asf_uid=asf_uid,
revision_number=revision_number,
primary_rel_path=None,
+ project_name=str(project_name),
+ version_name=str(version_name),
)
)
await data.commit()
@@ -239,6 +250,8 @@ async def metadata_update(
asf_uid=asf_uid,
revision_number=None,
primary_rel_path=None,
+ project_name=None,
+ version_name=None,
)
if schedule:
task.scheduled = schedule
@@ -263,8 +276,8 @@ async def queued(
raise ValueError("Cache key must contain a 'checker' key")
hash_val = hashes.compute_dict_hash(check_cache_key)
await attestable.write_checks_data(
- release.project.name,
- release.version,
+ release.safe_project_name,
+ release.safe_version_name,
revision_number,
primary_rel_path or "",
{check_cache_key["checker"]: hash_val},
@@ -464,6 +477,8 @@ async def workflow_update(
asf_uid=asf_uid,
revision_number=None,
primary_rel_path=None,
+ project_name=None,
+ version_name=None,
)
if schedule:
task.scheduled = schedule
@@ -574,9 +589,9 @@ async def _draft_file_checks(
data: db.Session,
path: pathlib.Path,
previous_version: sql.Release | None,
- project_name: str,
+ project_name: safe.ProjectName,
release: sql.Release,
- release_version: str,
+ release_version: safe.VersionName,
revision_number: str,
):
path_str = str(path)
@@ -600,8 +615,8 @@ async def _draft_file_checks(
revision_number,
path_str,
extra_args={
- "project_name": project_name,
- "version_name": release_version,
+ "project_name": str(project_name),
+ "version_name": str(release_version),
"revision_number": revision_number,
"previous_release_version": previous_version.version if previous_version else None,
"file_path": path_str,
diff --git a/atr/tasks/checks/__init__.py b/atr/tasks/checks/__init__.py
index 1dd9b0dc..99681200 100644
--- a/atr/tasks/checks/__init__.py
+++ b/atr/tasks/checks/__init__.py
@@ -39,6 +39,7 @@ import atr.db as db
import atr.hashes as hashes
import atr.log as log
import atr.models.github as github_models
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.paths as file_paths
import atr.util as util
@@ -50,8 +51,8 @@ import atr.util as util
class FunctionArguments:
recorder: Callable[[], Awaitable[Recorder]]
asf_uid: str
- project_name: str
- version_name: str
+ project_name: safe.ProjectName
+ version_name: safe.VersionName
revision_number: str
primary_rel_path: str | None
extra_args: dict[str, Any]
@@ -59,9 +60,9 @@ class FunctionArguments:
class Recorder:
checker: str
- release_name: str
- project_name: str
- version_name: str
+ release_name: safe.ReleaseName
+ project_name: safe.ProjectName
+ version_name: safe.VersionName
primary_rel_path: str | None
member_rel_path: str | None
revision_number: str
@@ -73,8 +74,8 @@ class Recorder:
self,
checker: str | Callable[..., Any],
inputs_hash: str | None,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
revision_number: str,
primary_rel_path: str | None = None,
member_rel_path: str | None = None,
@@ -99,8 +100,8 @@ class Recorder:
cls,
checker: str | Callable[..., Any],
inputs_hash: str,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
revision_number: str,
primary_rel_path: str | None = None,
member_rel_path: str | None = None,
@@ -144,7 +145,7 @@ class Recorder:
self.member_problems[status] = self.member_problems.get(status, 0) + 1
result = sql.CheckResult(
- release_name=self.release_name,
+ release_name=str(self.release_name),
revision_number=self.revision_number,
checker=self.checker,
primary_rel_path=primary_rel_path or self.primary_rel_path,
@@ -184,8 +185,9 @@ class Recorder:
async def project(self) -> sql.Project:
# TODO: Cache project
async with db.session() as data:
- return await data.project(name=self.project_name, _release_policy=True).demand(
- RuntimeError(f"Project {self.project_name} not found")
+ name_str = str(self.project_name)
+ return await data.project(name=name_str, _release_policy=True).demand(
+ RuntimeError(f"Project {name_str} not found")
)
async def primary_path_is_binary(self) -> bool:
@@ -325,7 +327,7 @@ async def resolve_cache_key(
args = {}
cache_key = {"checker": function_key(checker), "version": checker_version}
file_hash = None
- attestable_data = await attestable.load(release.project_name, release.version, revision)
+ attestable_data = await attestable.load(release.safe_project_name, release.safe_version_name, revision)
if attestable_data:
policy = sql.ReleasePolicy.model_validate(attestable_data.policy)
if not ignore_path:
@@ -335,7 +337,9 @@ async def resolve_cache_key(
policy = release.release_policy or release.project.release_policy
if not ignore_path:
if path is None:
- path = file_paths.revision_path_for_file(release.project_name, release.version, revision, file or "")
+ path = file_paths.revision_path_for_file(
+ release.safe_project_name, release.safe_version_name, revision, file or ""
+ )
file_hash = await hashes.compute_file_hash(path)
if file_hash:
cache_key["file_hash"] = file_hash
@@ -380,7 +384,7 @@ async def _resolve_all_files(release: sql.Release, rel_path: str | None = None)
return []
if not (
base_path := file_paths.base_path_for_revision(
- release.project_name, release.version, release.latest_revision_number
+ release.safe_project_name, release.safe_version_name, release.latest_revision_number
)
):
return []
@@ -403,7 +407,7 @@ async def _resolve_github_tp_sha(release: sql.Release, rel_path: str | None = No
if not release.latest_revision_number:
return ""
payload_path = attestable.github_tp_payload_path(
- release.project_name, release.version, release.latest_revision_number
+ release.safe_project_name, release.safe_version_name, release.latest_revision_number
)
if not await aiofiles.os.path.isfile(payload_path):
return ""
@@ -431,7 +435,7 @@ async def _resolve_unsuffixed_file_hash(release: sql.Release, rel_path: str | No
if (not rel_path) or (not release.latest_revision_number):
return ""
abs_path = file_paths.revision_path_for_file(
- release.project_name, release.version, release.latest_revision_number, rel_path
+ release.safe_project_name, release.safe_version_name, release.latest_revision_number, rel_path
)
plain_path = abs_path.with_suffix("")
if await aiofiles.os.path.isfile(plain_path):
diff --git a/atr/tasks/checks/compare.py b/atr/tasks/checks/compare.py
index 013f7839..f2d29881 100644
--- a/atr/tasks/checks/compare.py
+++ b/atr/tasks/checks/compare.py
@@ -42,6 +42,7 @@ import atr.config as config
import atr.log as log
import atr.models.github as github_models
import atr.models.results as results
+import atr.models.safe as safe
import atr.paths as paths
import atr.tasks.checks as checks
import atr.util as util
@@ -373,7 +374,7 @@ async def _find_archive_root(archive_path: pathlib.Path, extract_dir: pathlib.Pa
async def _load_tp_payload(
- project_name: str, version_name: str, revision_number: str
+ project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str
) -> github_models.TrustedPublisherPayload | None:
payload_path = attestable.github_tp_payload_path(project_name, version_name, revision_number)
if not await aiofiles.os.path.isfile(payload_path):
diff --git a/atr/tasks/distribution.py b/atr/tasks/distribution.py
index c1e72515..0c962e9c 100644
--- a/atr/tasks/distribution.py
+++ b/atr/tasks/distribution.py
@@ -63,13 +63,13 @@ async def status_check(args: DistributionStatusCheckArgs, *, task_id: int | None
async with storage.write_as_committee_member(dist.release.project.committee_name, dist.created_by) as w:
if dist.retries >= _RETRY_LIMIT:
await w.distributions.delete_distribution(
- dist.release_name, dist.platform, dist.owner_namespace, dist.package, dist.version
+ dist.safe_release_name, dist.platform, dist.owner_namespace, dist.package, dist.version
)
log.error(f"Distribution {name} failed {_RETRY_LIMIT} times, skipping")
continue
log.warning(f"Retrying distribution {name}")
await w.distributions.record_from_data(
- dist.release_name,
+ dist.safe_release_name,
dist.staging,
dd,
allow_retries=True,
diff --git a/atr/tasks/gha.py b/atr/tasks/gha.py
index 6be367b3..f0c5fc9b 100644
--- a/atr/tasks/gha.py
+++ b/atr/tasks/gha.py
@@ -28,6 +28,7 @@ import atr.config as config
import atr.db as db
import atr.log as log
import atr.models.results as results
+import atr.models.safe as safe
import atr.models.schema as schema
import atr.models.sql as sql
import atr.storage as storage
@@ -50,8 +51,8 @@ class DistributionWorkflow(schema.Strict):
package: str = schema.description("Package to distribute")
version: str = schema.description("Version to distribute")
staging: bool = schema.description("Whether this is a staging distribution")
- project_name: str = schema.description("Project name in ATR")
- version_name: str = schema.description("Version name in ATR")
+ project_name: safe.ProjectName = schema.description("Project name in ATR")
+ version_name: safe.VersionName = schema.description("Version name in ATR")
phase: str = schema.description("Release phase in ATR")
asf_uid: str = schema.description("ASF UID of the user triggering the workflow")
committee_name: str = schema.description("Committee name in ATR")
diff --git a/atr/tasks/keys.py b/atr/tasks/keys.py
index 8854fb66..4cd48d83 100644
--- a/atr/tasks/keys.py
+++ b/atr/tasks/keys.py
@@ -16,6 +16,7 @@
# under the License.
import atr.models.results as results
+import atr.models.safe as safe
import atr.models.schema as schema
import atr.storage as storage
import atr.tasks.checks as checks
@@ -25,8 +26,8 @@ class ImportFile(schema.Strict):
"""Import a KEYS file from a draft release candidate revision."""
asf_uid: str
- project_name: str
- version_name: str
+ project_name: safe.ProjectName
+ version_name: safe.VersionName
@checks.with_model(ImportFile)
diff --git a/atr/tasks/quarantine.py b/atr/tasks/quarantine.py
index 37905842..cb027289 100644
--- a/atr/tasks/quarantine.py
+++ b/atr/tasks/quarantine.py
@@ -32,6 +32,7 @@ import atr.detection as detection
import atr.hashes as hashes
import atr.log as log
import atr.models.results as results
+import atr.models.safe as safe
import atr.models.schema as schema
import atr.models.sql as sql
import atr.paths as paths
@@ -65,8 +66,8 @@ async def validate(args: QuarantineValidate) -> results.Results | None:
return None
release = quarantined.release
- project_name = release.project_name
- version_name = release.version
+ project_name = release.safe_project_name
+ version_name = release.safe_version_name
quarantine_dir = paths.quarantine_directory(quarantined)
if not await aiofiles.os.path.isdir(quarantine_dir):
@@ -157,8 +158,8 @@ async def _mark_failed(
async def _promote(
quarantined: sql.Quarantined,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
release_name: str,
quarantine_dir: str,
) -> None:
@@ -204,7 +205,7 @@ async def _promote(
previous_attestable=previous_attestable,
project_name=project_name,
release=release,
- release_name=release_name,
+ release_name=release.safe_name,
temp_dir=quarantine_dir,
temp_dir_path=quarantine_dir_path,
version_name=version_name,
diff --git a/atr/tasks/sbom.py b/atr/tasks/sbom.py
index 7c5ac7e2..185fbce4 100644
--- a/atr/tasks/sbom.py
+++ b/atr/tasks/sbom.py
@@ -28,6 +28,7 @@ import atr.archives as archives
import atr.config as config
import atr.log as log
import atr.models.results as results
+import atr.models.safe as safe
import atr.models.schema as schema
import atr.models.sql as sql
import atr.paths as paths
@@ -69,20 +70,20 @@ class SBOMScoringError(Exception):
class FileArgs(schema.Strict):
- project_name: str = schema.description("Project name")
- version_name: str = schema.description("Version name")
+ project_name: safe.ProjectName = schema.description("Project name")
+ version_name: safe.VersionName = schema.description("Version name")
revision_number: str = schema.description("Revision number")
file_path: str = schema.description("Relative path to the SBOM file")
asf_uid: str | None = None
class ScoreArgs(FileArgs):
- previous_release_version: str | None = schema.description("Previous release version")
+ previous_release_version: safe.VersionName | None = schema.description("Previous release version")
@checks.with_model(FileArgs)
async def augment(args: FileArgs) -> results.Results | None:
- base_dir = paths.get_unfinished_dir() / args.project_name / args.version_name / args.revision_number
+ base_dir = paths.get_unfinished_dir() / str(args.project_name) / str(args.version_name) / args.revision_number
if not await aiofiles.os.path.isdir(base_dir):
raise SBOMScoringError("Revision directory does not exist", {"base_dir": str(base_dir)})
full_path = base_dir / args.file_path
@@ -142,7 +143,7 @@ async def generate_cyclonedx(args: GenerateCycloneDX) -> results.Results | None:
@checks.with_model(FileArgs)
async def osv_scan(args: FileArgs) -> results.Results | None:
- base_dir = paths.get_unfinished_dir() / args.project_name / args.version_name / args.revision_number
+ base_dir = paths.get_unfinished_dir() / str(args.project_name) / str(args.version_name) / args.revision_number
if not await aiofiles.os.path.isdir(base_dir):
raise SBOMScanningError("Revision directory does not exist", {"base_dir": str(base_dir)})
full_path = base_dir / args.file_path
@@ -199,7 +200,7 @@ async def osv_scan(args: FileArgs) -> results.Results | None:
@checks.with_model(FileArgs)
async def score_qs(args: FileArgs) -> results.Results | None:
- base_dir = paths.get_unfinished_dir() / args.project_name / args.version_name / args.revision_number
+ base_dir = paths.get_unfinished_dir() / str(args.project_name) / str(args.version_name) / args.revision_number
if not await aiofiles.os.path.isdir(base_dir):
raise SBOMScoringError("Revision directory does not exist", {"base_dir": str(base_dir)})
full_path = base_dir / args.file_path
@@ -235,10 +236,10 @@ async def score_qs(args: FileArgs) -> results.Results | None:
@checks.with_model(ScoreArgs)
async def score_tool(args: ScoreArgs) -> results.Results | None:
- base_dir = paths.get_unfinished_dir() / args.project_name / args.version_name / args.revision_number
+ base_dir = paths.get_unfinished_dir() / str(args.project_name) / str(args.version_name) / args.revision_number
previous_base_dir = None
if args.previous_release_version is not None:
- previous_base_dir = paths.get_finished_dir() / args.project_name / args.previous_release_version
+ previous_base_dir = paths.get_finished_dir() / str(args.project_name) / str(args.previous_release_version)
if not await aiofiles.os.path.isdir(base_dir):
raise SBOMScoringError("Revision directory does not exist", {"base_dir": str(base_dir)})
full_path = base_dir / args.file_path
diff --git a/atr/tasks/svn.py b/atr/tasks/svn.py
index 5b6c1829..0c469488 100644
--- a/atr/tasks/svn.py
+++ b/atr/tasks/svn.py
@@ -24,6 +24,7 @@ import aioshutil
import atr.log as log
import atr.models.results as results
+import atr.models.safe as safe
import atr.models.schema as schema
import atr.models.sql as sql
import atr.storage as storage
@@ -36,8 +37,8 @@ class SvnImport(schema.Strict):
svn_url: str
revision: str
target_subdirectory: str | None
- project_name: str
- version_name: str
+ project_name: safe.ProjectName
+ version_name: safe.VersionName
asf_uid: str
diff --git a/atr/tasks/vote.py b/atr/tasks/vote.py
index 688d4c05..a4f0087e 100644
--- a/atr/tasks/vote.py
+++ b/atr/tasks/vote.py
@@ -22,6 +22,7 @@ import atr.db.interaction as interaction
import atr.log as log
import atr.mail as mail
import atr.models.results as results
+import atr.models.safe as safe
import atr.models.schema as schema
import atr.storage as storage
import atr.tasks.checks as checks
@@ -31,7 +32,7 @@ import atr.util as util
class Initiate(schema.Strict):
"""Arguments for the task to start a vote."""
- release_name: str = schema.description("The name of the release to vote on")
+ release_name: safe.ReleaseName = schema.description("The name of the release to vote on")
email_to: str = schema.description("The mailing list address to send the vote email to")
vote_duration: int = schema.description("Duration of the vote in hours")
initiator_id: str = schema.description("ASF ID of the vote initiator")
@@ -68,16 +69,20 @@ async def _initiate_core_logic(args: Initiate) -> results.Results | None:
raise VoteInitiationError("Invalid destination email address")
async with db.session() as data:
- release = await data.release(name=args.release_name, _project=True, _committee=True).demand(
- VoteInitiationError(f"Release {args.release_name} not found")
+ release = await data.release(name=str(args.release_name), _project=True, _committee=True).demand(
+ VoteInitiationError(f"Release {args.release_name!s} not found")
)
latest_revision_number = release.latest_revision_number
if latest_revision_number is None:
- raise VoteInitiationError(f"No revisions found for release {args.release_name}")
+ raise VoteInitiationError(f"No revisions found for release {args.release_name!s}")
- ongoing_tasks = await interaction.tasks_ongoing(release.project.name, release.version, latest_revision_number)
+ ongoing_tasks = await interaction.tasks_ongoing(
+ release.safe_project_name, release.safe_version_name, latest_revision_number
+ )
if ongoing_tasks > 0:
- raise VoteInitiationError(f"Cannot start vote for {args.release_name} as {ongoing_tasks} are not complete")
+ raise VoteInitiationError(
+ f"Cannot start vote for {args.release_name!s} as {ongoing_tasks} are not complete"
+ )
# Calculate vote end date
vote_duration_hours = args.vote_duration
diff --git a/atr/templates/check-selected-path-table.html b/atr/templates/check-selected-path-table.html
index 3f5b46cb..a7496118 100644
--- a/atr/templates/check-selected-path-table.html
+++ b/atr/templates/check-selected-path-table.html
@@ -48,7 +48,7 @@
{% endif %}
</td>
<td class="py-2">
- <a href="{{ as_url(get.file.selected_path, project_name=project_name, version_name=version_name, file_path=path) }}"
+ <a href="{{ as_url(get.file.selected_path, project_name=project_name|string, version_name=version_name|string, file_path=path) }}"
title="View file {{ path }}"
class="text-decoration-none text-reset">
{% if has_errors or has_warnings %}
@@ -62,7 +62,7 @@
<div class="d-flex justify-content-end align-items-center gap-2">
{% if path|string == "KEYS" %}
<form method="post"
- action="{{ as_url(post.keys.import_selected_revision, project_name=project_name, version_name=version_name) }}"
+ action="{{ as_url(post.keys.import_selected_revision, project_name=project_name|string, version_name=version_name|string) }}"
class="d-inline mb-0">
{{ csrf_input|safe }}
@@ -70,20 +70,20 @@
</form>
{% endif %}
{% if path.suffixes[-2:] == [".cdx", ".json"] %}
- <a href="{{ as_url(get.sbom.report, project_name=project_name, version_name=version_name, file_path=path) }}"
+ <a href="{{ as_url(get.sbom.report, project_name=project_name|string, version_name=version_name|string, file_path=path) }}"
class="btn btn-sm btn-outline-secondary">SBOM report</a>
{% endif %}
{% if has_blockers %}
- <a href="{{ as_url(get.report.selected_path, project_name=project_name, version_name=version_name, rel_path=path) }}"
+ <a href="{{ as_url(get.report.selected_path, project_name=project_name|string, version_name=version_name|string, rel_path=path) }}"
class="btn btn-sm atr-btn-outline-blocker"><i class="bi bi-exclamation-triangle me-1"></i> Show {{ info.errors[path]|length }} {{ "error" if info.errors[path]|length == 1 else "errors" }}</a>
{% elif has_errors %}
- <a href="{{ as_url(get.report.selected_path, project_name=project_name, version_name=version_name, rel_path=path) }}"
+ <a href="{{ as_url(get.report.selected_path, project_name=project_name|string, version_name=version_name|string, rel_path=path) }}"
class="btn btn-sm btn-outline-danger"><i class="bi bi-exclamation-triangle me-1"></i> Show {{ info.errors[path]|length }} {{ "error" if info.errors[path]|length == 1 else "errors" }}</a>
{% elif has_warnings %}
- <a href="{{ as_url(get.report.selected_path, project_name=project_name, version_name=version_name, rel_path=path) }}"
+ <a href="{{ as_url(get.report.selected_path, project_name=project_name|string, version_name=version_name|string, rel_path=path) }}"
class="btn btn-sm btn-outline-warning">Show {{ info.warnings[path]|length }} {{ "warning" if info.warnings[path]|length == 1 else "warnings" }}</a>
{% elif info and (path in info.successes) %}
- <a href="{{ as_url(get.report.selected_path, project_name=project_name, version_name=version_name, rel_path=path) }}"
+ <a href="{{ as_url(get.report.selected_path, project_name=project_name|string, version_name=version_name|string, rel_path=path) }}"
class="btn btn-sm btn-outline-success"
title="Show report for {{ path }}">Show report</a>
{% else %}
@@ -99,7 +99,7 @@
aria-controls="actions-{{ row_id }}"
title="Show more actions for {{ path }}">More</button>
{% elif phase == "release_candidate" %}
- <a href="{{ as_url(get.download.path, project_name=release.project.name, version_name=release.version, file_path=path) }}"
+ <a href="{{ as_url(get.download.path, project_name=release.project.name|string, version_name=release.version|string, file_path=path) }}"
title="Download file {{ path }}"
class="btn btn-sm btn-outline-secondary">Download</a>
{% endif %}
@@ -114,10 +114,10 @@
<div class="d-flex justify-content-end align-items-center gap-2"
role="group"
aria-label="More file actions for {{ path }}">
- <a href="{{ as_url(get.download.path, project_name=release.project.name, version_name=release.version, file_path=path) }}"
+ <a href="{{ as_url(get.download.path, project_name=release.project.name|string, version_name=release.version|string, file_path=path) }}"
title="Download file {{ path }}"
class="btn btn-sm btn-outline-secondary">Download</a>
- <a href="{{ as_url(get.draft.tools, project_name=project_name, version_name=version_name, file_path=path) }}"
+ <a href="{{ as_url(get.draft.tools, project_name=release.project.name|string, version_name=release.version|string, file_path=path) }}"
title="Tools for file {{ path }}"
class="btn btn-sm btn-outline-secondary">Tools</a>
{{ delete_file_forms[path|string] }}
diff --git a/atr/templates/check-selected-release-info.html b/atr/templates/check-selected-release-info.html
index 3c602ff6..60b22ce4 100644
--- a/atr/templates/check-selected-release-info.html
+++ b/atr/templates/check-selected-release-info.html
@@ -7,7 +7,7 @@
<div class="col-md-6">
<p>
<strong>Project:</strong>
- <a href="{{ as_url(get.projects.view, project_name=release.project.name) }}">{{ release.project.display_name }}</a>
+ <a href="{{ as_url(get.projects.view, project_name=(release.project.name|string)) }}">{{ release.project.display_name }}</a>
</p>
<p>
<strong>Label:</strong> {{ release.name }}
@@ -25,7 +25,7 @@
{% if (phase == "release_candidate_draft") and revision_time %}
<p>
<strong>Revision:</strong>
- <a href="{{ as_url(get.revisions.selected, project_name=project_name, version_name=version_name) }}#{{ revision_number }}">
+ <a href="{{ as_url(get.revisions.selected, project_name=project_name|string, version_name=version_name|string) }}#{{ revision_number }}">
{{ format_datetime(revision_time) }}
</a>
{% if revision_editor %}by {{ revision_editor }}{% endif %}
@@ -41,11 +41,11 @@
</div>
<div class="d-flex flex-wrap gap-2">
{% if phase == "release_candidate_draft" %}
- <a href="{{ as_url(get.upload.selected, project_name=release.project.name, version_name=release.version) }}"
+ <a href="{{ as_url(get.upload.selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
title="Upload files to this draft"
class="btn btn-primary"><i class="bi bi-upload me-1"></i> Upload files</a>
- <a href="{{ as_url(get.download.all_selected, project_name=release.project.name, version_name=release.version) }}"
+ <a href="{{ as_url(get.download.all_selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
title="Download {%- if has_files -%}files{%- else -%}links{%- endif -%}"
class="btn btn-primary"><i class="bi bi-download me-1"></i> Download
{% if has_files %}
@@ -54,7 +54,7 @@
links
{% endif %}
</a>
- <a href="{{ as_url(get.revisions.selected, project_name=release.project.name, version_name=release.version) }}"
+ <a href="{{ as_url(get.revisions.selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
title="View revision history"
class="btn btn-secondary"><i class="bi bi-clock-history me-1"></i> Revisions</a>
{% if revision_number %}
@@ -62,13 +62,13 @@
{% set blocked_title = "Fix blockers before starting a vote" if blocker_errors else "Fix errors before starting a vote" %}
{% if has_files and release.project.policy_manual_vote and (ongoing_tasks_count == 0) and (not vote_blocked) %}
<a id="start-vote-button"
- href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
+ href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
title="Start a manual vote on this draft"
class="btn btn-success"><i class="bi bi-check-circle me-1"></i> Start manual vote</a>
{% elif has_files and release.project.policy_manual_vote and (not vote_blocked) %}
<a id="start-vote-button"
- href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
- data-vote-href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
+ href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
+ data-vote-href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
title="Background tasks must complete first"
class="btn btn-success disabled"
role="button"
@@ -76,7 +76,7 @@
tabindex="-1"><i class="bi bi-check-circle me-1"></i> Start manual vote</a>
{% elif has_files and release.project.policy_manual_vote and vote_blocked %}
<a id="start-vote-button"
- href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
+ href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
title="{{ blocked_title }}"
class="btn btn-success disabled"
role="button"
@@ -84,13 +84,13 @@
tabindex="-1"><i class="bi bi-check-circle me-1"></i> Start manual vote</a>
{% elif has_files and (not vote_blocked) and (ongoing_tasks_count == 0) %}
<a id="start-vote-button"
- href="{{ as_url(get.voting.selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
+ href="{{ as_url(get.voting.selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
title="Start a vote on this draft"
class="btn btn-success"><i class="bi bi-check-circle me-1"></i> Start voting</a>
{% elif has_files and (not vote_blocked) %}
<a id="start-vote-button"
- href="{{ as_url(get.voting.selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
- data-vote-href="{{ as_url(get.voting.selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
+ href="{{ as_url(get.voting.selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
+ data-vote-href="{{ as_url(get.voting.selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
title="Background tasks must complete first"
class="btn btn-success disabled"
role="button"
@@ -98,7 +98,7 @@
tabindex="-1"><i class="bi bi-check-circle me-1"></i> Start voting</a>
{% elif has_files and vote_blocked %}
<a id="start-vote-button"
- href="{{ as_url(get.voting.selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
+ href="{{ as_url(get.voting.selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
title="{{ blocked_title }}"
class="btn btn-success disabled"
role="button"
@@ -106,7 +106,7 @@
tabindex="-1"><i class="bi bi-check-circle me-1"></i> Start voting</a>
{% else %}
<a id="start-vote-button"
- href="{{ as_url(get.voting.selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
+ href="{{ as_url(get.voting.selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
title="Upload files to enable voting"
class="btn btn-success disabled"
role="button"
@@ -116,15 +116,15 @@
{% endif %}
<a href="#more-actions" class="btn btn-outline-secondary"><i class="bi bi-gear me-1"></i> More actions</a>
{% elif phase == "release_candidate" %}
- <a href="{{ as_url(get.download.all_selected, project_name=release.project.name, version_name=release.version) }}"
+ <a href="{{ as_url(get.download.all_selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
class="btn btn-primary"><i class="bi bi-download me-1"></i> Download files</a>
- <a href="{{ as_url(get.file.selected, project_name=release.project.name, version_name=release.version) }}"
+ <a href="{{ as_url(get.file.selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
class="btn btn-secondary"><i class="bi bi-eye me-1"></i> View files</a>
{% if can_resolve and release.vote_manual %}
- <a href="{{ as_url(get.manual.resolve_selected, project_name=release.project.name, version_name=release.version) }}"
+ <a href="{{ as_url(get.manual.resolve_selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
class="btn btn-success"><i class="bi bi-clipboard-check me-1"></i> Resolve vote</a>
{% elif can_resolve and resolve_form %}
- <form action="{{ as_url(post.resolve.selected, project_name=release.project.name, version_name=release.version) }}"
+ <form action="{{ as_url(post.resolve.selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
method="post"
class="mb-0">
{{ csrf_input|safe }}
diff --git a/atr/templates/check-selected.html b/atr/templates/check-selected.html
index 24f91147..de8ba6c0 100644
--- a/atr/templates/check-selected.html
+++ b/atr/templates/check-selected.html
@@ -156,9 +156,9 @@
</div>
<p>
<a class="btn btn-primary"
- href="{{ as_url(get.distribution.stage_automate, project_name=release.project.name, version_name=release.version) }}">Distribute</a>
+ href="{{ as_url(get.distribution.stage_automate, project_name=release.project.name|string, version_name=(release.version|string)) }}">Distribute</a>
<a class="btn btn-secondary"
- href="{{ as_url(get.distribution.stage_record, project_name=release.project.name, version_name=release.version) }}">Record a manual distribution</a>
+ href="{{ as_url(get.distribution.stage_record, project_name=release.project.name|string, version_name=(release.version|string)) }}">Record a manual distribution</a>
</p>
<h2 id="more-actions">More actions</h2>
<h3 id="ignored-checks" class="mt-4">Ignored checks</h3>
@@ -212,7 +212,7 @@
<p>No ignored checks found.</p>
{% endif %}
<p>
- You can also <a href="{{ as_url(get.ignores.ignores, project_name=release.project_name) }}">manage which check results are ignored</a>.
+ You can also <a href="{{ as_url(get.ignores.ignores, project_name=release.project_name|string) }}">manage which check results are ignored</a>.
</p>
{% if is_viewing_as_admin_fn(current_user.uid) %}
diff --git a/atr/templates/committee-directory.html b/atr/templates/committee-directory.html
index 3eedfe0c..0edaf7db 100644
--- a/atr/templates/committee-directory.html
+++ b/atr/templates/committee-directory.html
@@ -116,11 +116,11 @@
{% if committee.projects %}
{% for project in committee.projects|sort(attribute="name") %}
<div class="card mb-3 shadow-sm page-project-subcard {% if loop.index > max_initial_projects %}page-project-extra d-none{% endif %} {% if project.status.value.lower() != "active" %}page-project-inactive{% endif %}"
- data-project-url="{{ as_url(get.projects.view, project_name=project.name) }}">
+ data-project-url="{{ as_url(get.projects.view, project_name=(project.name|string)) }}">
<div class="card-body p-3 d-flex flex-column h-100">
<div class="d-flex justify-content-between align-items-start">
<p class="mb-1 me-2 fs-6">
- <a href="{{ as_url(get.projects.view, project_name=project.name) }}"
+ <a href="{{ as_url(get.projects.view, project_name=(project.name|string)) }}"
class="text-decoration-none stretched-link">{{ project.display_name }}</a>
</p>
<div>
diff --git a/atr/templates/committee-view.html b/atr/templates/committee-view.html
index 6ce1f66d..4c99e552 100644
--- a/atr/templates/committee-view.html
+++ b/atr/templates/committee-view.html
@@ -29,7 +29,7 @@
<ul>
{% for project in projects %}
<li>
- <a href="{{ as_url(get.projects.view, project_name=project.name) }}">{{ project.display_name }}</a>
+ <a href="{{ as_url(get.projects.view, project_name=(project.name|string)) }}">{{ project.display_name }}</a>
</li>
{% endfor %}
</ul>
diff --git a/atr/templates/download-all.html b/atr/templates/download-all.html
index 5a5e4b22..4c8e7057 100644
--- a/atr/templates/download-all.html
+++ b/atr/templates/download-all.html
@@ -63,7 +63,7 @@
The archive is generated on the fly, which may take a while for very large releases.
</p>
<p>
- <a href="{{ as_url(get.download.zip_selected, project_name=release.project.name, version_name=release.version) }}"
+ <a href="{{ as_url(get.download.zip_selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
class="btn btn-primary btn-lg">
<i class="bi bi-file-earmark-zip me-2"></i>Download {{ release.name }}.zip
</a>
@@ -88,17 +88,17 @@
<h3 id="download-browser" class="mt-4">Using your browser</h3>
<p>
- You can download the files one by one using your browser from the <a href="{{ as_url(get.download.path_empty, project_name=release.project.name, version_name=release.version) }}">download folder</a>. Clicking a link to any file will download it, as it is served as <code>application/octet-stream</code>.
+ You can download the files one by one using your browser from the <a href="{{ as_url(get.download.path_empty, project_name=release.project.name|string, version_name=(release.version|string)) }}">download folder</a>. Clicking a link to any file will download it, as it is served as <code>application/octet-stream</code>.
</p>
<h3 id="download-curl" class="mt-4">Using curl</h3>
<p>You can download all of the files in this release using curl with the following command:</p>
<!-- TODO: Add a button to copy the command to the clipboard -->
<pre class="bg-light border rounded p-3 mb-3">
-curl{% if server_domain == "localhost.apache.org" %} --insecure{% endif %} -fsS https://{{ server_host }}{{ as_url(get.download.sh_selected, project_name=release.project.name, version_name=release.version) }} | sh
+curl{% if server_domain == "localhost.apache.org" %} --insecure{% endif %} -fsS https://{{ server_host }}{{ as_url(get.download.sh_selected, project_name=release.project.name|string, version_name=(release.version|string)) }} | sh
</pre>
<p>
- This downloads the files into the <em>current directory</em>. Ensure that you create a new empty directory, and change to it, before running the command. The script requires curl and a POSIX compliant version of sh. It works by downloading a POSIX complaint shell script straight into your shell. You can of course <a href="{{ as_url(get.download.sh_selected, project_name=release.project.name, version_name=release.version) }}">download the script</a> and audit it before running it.
+ This downloads the files into the <em>current directory</em>. Ensure that you create a new empty directory, and change to it, before running the command. The script requires curl and a POSIX compliant version of sh. It works by downloading a POSIX complaint shell script straight into your shell. You can of course <a href="{{ as_url(get.download.sh_selected, project_name=release.project.name|string, version_name=(release.version|string)) }}">download the script</a> and audit it before [...]
</p>
<h3 id="download-rsync" class="mt-4">Using rsync</h3>
@@ -112,7 +112,7 @@ rsync -av -e 'ssh -p 2222' {{ asf_id }}@{{ server_domain }}:/{{ release.project.
<h3 id="download-wget" class="mt-4">Using wget</h3>
<p>You can download all of the files in this release using wget with the following command:</p>
<pre class="bg-light border rounded p-3 mb-3">
-wget -r -np -nH --cut-dirs=4 --default-page=.index.html{% if server_domain == "localhost.apache.org" %} --no-check-certificate{% endif %} https://{{ server_host }}{{ as_url(get.download.path_empty, project_name=release.project.name, version_name=release.version) }}
+wget -r -np -nH --cut-dirs=4 --default-page=.index.html{% if server_domain == "localhost.apache.org" %} --no-check-certificate{% endif %} https://{{ server_host }}{{ as_url(get.download.path_empty, project_name=release.project.name|string, version_name=(release.version|string)) }}
</pre>
<p>
This downloads the files into the <em>current directory</em>. Ensure that you create a new empty directory, and change to it, before running the command.
diff --git a/atr/templates/draft-tools.html b/atr/templates/draft-tools.html
index 718f8f07..3a77ca29 100644
--- a/atr/templates/draft-tools.html
+++ b/atr/templates/draft-tools.html
@@ -5,7 +5,7 @@
{%- block description -%}Manage a file in the candidate draft using tools.{%- endblock description -%}
{% block content %}
- <a href="{{ as_url(get.compose.selected, project_name=project_name, version_name=version_name) }}"
+ <a href="{{ as_url(get.compose.selected, project_name=project_name|string, version_name=version_name|string) }}"
class="atr-back-link">← Back to Compose release</a>
<div class="p-3 mb-4 bg-light border rounded">
diff --git a/atr/templates/includes/topnav.html b/atr/templates/includes/topnav.html
index 081c55a1..d46b1a10 100644
--- a/atr/templates/includes/topnav.html
+++ b/atr/templates/includes/topnav.html
@@ -42,7 +42,7 @@
</li>
<li>
<a class="dropdown-item fw-bold"
- href="{{ as_url(get.projects.view, project_name=project_name) }}">{{ project_short_display_name }}</a>
+ href="{{ as_url(get.projects.view, project_name=project_name|string) }}">{{ project_short_display_name }}</a>
</li>
{% for release in releases %}
<li>
@@ -64,7 +64,7 @@
{% for project_name, project_full_name in user_projects[:max_projects] %}
<li>
<a class="dropdown-item"
- href="{{ as_url(get.start.selected, project_name=project_name) }}"><i class="bi bi-plus-circle"></i>
+ href="{{ as_url(get.start.selected, project_name=project_name|string) }}"><i class="bi bi-plus-circle"></i>
{{ project_full_name.removeprefix("Apache ").removesuffix(" (Incubating)") }}</a>
</li>
{% endfor %}
diff --git a/atr/templates/index-committer.html b/atr/templates/index-committer.html
index ce5f428c..ea946773 100644
--- a/atr/templates/index-committer.html
+++ b/atr/templates/index-committer.html
@@ -67,7 +67,7 @@
<div class="mb-5" id="project-{{ project_id }}">
<h2 class="border-bottom border-secondary pb-2 mb-3">
{{ display_name_cleaned }}
- {% if project.committee.is_podling or project.name.startswith("incubator-") %}
+ {% if project.committee.is_podling or (project.name|string).startswith("incubator-") %}
<span class="text-muted fw-normal fs-5">(Incubating)</span>
<img src="{{ static_url('svg/apache_incubator.svg') }}"
alt=""
@@ -87,7 +87,7 @@
</h2>
<p class="mb-3">
- <a href="{{ as_url(get.projects.view, project_name=project.name) }}"
+ <a href="{{ as_url(get.projects.view, project_name=(project.name|string) )}}"
class="text-decoration-none me-2">About this project</a>
{% if project.committee.name in current_user.committees %}
<span class="text-muted me-2">/</span>
@@ -96,7 +96,7 @@
{% endif %}
{% if completed_releases %}
<span class="text-muted me-2">/</span>
- <a href="{{ as_url(get.release.finished, project_name=project.name) }}"
+ <a href="{{ as_url(get.release.finished, project_name=(project.name|string)) }}"
class="text-decoration-none">Finished releases</a>
{% endif %}
</p>
@@ -145,7 +145,7 @@
</a>
{% endfor %}
- <a href="{{ as_url(get.start.selected, project_name=project.name) }}"
+ <a href="{{ as_url(get.start.selected, project_name=(project.name|string)) }}"
title="Start a new {{ project.display_name }} release"
class="text-decoration-none">
<div class="card h-100 shadow-sm atr-cursor-pointer page-card">
diff --git a/atr/templates/project-select.html b/atr/templates/project-select.html
index 0b0f7b06..0f3409ba 100644
--- a/atr/templates/project-select.html
+++ b/atr/templates/project-select.html
@@ -11,16 +11,16 @@
<div class="row row-cols-1 row-cols-md-2 row-cols-lg-3 g-4">
{% for project in user_projects %}
<div class="col">
- <a href="{{ as_url(get.release.select, project_name=project.name) }}"
+ <a href="{{ as_url(get.release.select, project_name=(project.name|string)) }}"
class="text-decoration-none">
{# TODO: We're only setting data-project-url for style #}
<div class="card h-100 shadow-sm atr-cursor-pointer"
- data-project-url="{{ as_url(get.release.select, project_name=project.name) }}">
+ data-project-url="{{ as_url(get.release.select, project_name=(project.name|string)) }}">
<div class="card-body">
<h3 class="card-title fs-5 mb-2">{{ project.display_name }}</h3>
<h4 class="card-subtitle mb-2 text-muted fs-6">{{ project.name }}</h4>
<p>
- {% if project.committee.is_podling or project.name.startswith("incubator-") %}
+ {% if project.committee.is_podling or (project.name|string).startswith("incubator-") %}
<img src="https://incubator.apache.org/images/SVG/apache_incubator.svg"
alt="" />
{% else %}
diff --git a/atr/templates/projects.html b/atr/templates/projects.html
index 4d30e8cf..862be6cc 100644
--- a/atr/templates/projects.html
+++ b/atr/templates/projects.html
@@ -37,12 +37,12 @@
{% endif %}
<div class="col">
<div class="card h-100 shadow-sm position-relative page-project-card {{ '' if project.status.value.lower() == 'active' else 'bg-body-secondary' }}"
- data-project-url="{{ as_url(get.projects.view, project_name=project.name) }}"
+ data-project-url="{{ as_url(get.projects.view, project_name=(project.name|string)) }}"
data-is-participant="{{ 'true' if is_part else 'false' }}">
<div class="card-body">
<div class="row g-1">
<div class="col-sm">
- <h3 class="card-title fs-4 mb-3"><a href="{{ as_url(get.projects.view, project_name=project.name) }}" class="text-decoration-none text-body stretched-link">{{ project.display_name }}</a></h3>
+ <h3 class="card-title fs-4 mb-3"><a href="{{ as_url(get.projects.view, project_name=(project.name|string)) }}" class="text-decoration-none text-body stretched-link">{{ project.display_name }}</a></h3>
</div>
{% if project.status.value.lower() != 'active' %}
<div class="col-sm-2">
diff --git a/atr/templates/release-select.html b/atr/templates/release-select.html
index 9a179fde..d072e992 100644
--- a/atr/templates/release-select.html
+++ b/atr/templates/release-select.html
@@ -30,13 +30,13 @@
{% set target_url = None %}
{# TODO: Use mappings.py #}
{% if phase == "release_candidate_draft" %}
- {% set target_url = as_url(get.compose.selected, project_name=project.name, version_name=release.version) %}
+ {% set target_url = as_url(get.compose.selected, project_name=project.name|string, version_name=(release.version|string)) %}
{% set badge_class = "bg-primary" %}
{% elif phase == "release_candidate" %}
- {% set target_url = as_url(get.vote.selected, project_name=project.name, version_name=release.version) %}
+ {% set target_url = as_url(get.vote.selected, project_name=project.name|string, version_name=(release.version|string)) %}
{% set badge_class = "bg-warning text-dark" %}
{% elif phase == "release_preview" %}
- {% set target_url = as_url(get.announce.selected, project_name=project.name, version_name=release.version) %}
+ {% set target_url = as_url(get.announce.selected, project_name=project.name|string, version_name=(release.version|string)) %}
{% set badge_class = "bg-success" %}
{% endif %}
diff --git a/atr/templates/releases-finished.html b/atr/templates/releases-finished.html
index c57ba4da..b8f05723 100644
--- a/atr/templates/releases-finished.html
+++ b/atr/templates/releases-finished.html
@@ -21,11 +21,11 @@
<strong class="card-title fs-5">{{ release.version }}</strong>
<p class="card-text text-muted">Released on {{ format_datetime(release.created) }}</p>
<div class="mt-auto">
- <a href="{{ as_url(get.download.all_selected, project_name=release.project.name, version_name=release.version) }}"
+ <a href="{{ as_url(get.download.all_selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
class="btn btn-outline-primary w-100 mb-2">
<i class="bi bi-download me-1"></i> Download files
</a>
- <a href="{{ as_url(get.file.selected, project_name=release.project.name, version_name=release.version) }}"
+ <a href="{{ as_url(get.file.selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
class="btn btn-outline-secondary w-100">
<i class="bi bi-folder2-open me-1"></i> View files
</a>
diff --git a/atr/templates/releases.html b/atr/templates/releases.html
index 4e5111f8..ed044657 100644
--- a/atr/templates/releases.html
+++ b/atr/templates/releases.html
@@ -29,7 +29,7 @@
<div class="card-body">
<h3 class="card-title mb-3">{{ project_display_name }}</h3>
<p class="card-text">
- <a href="{{ as_url(get.release.finished, project_name=project.name) }}"
+ <a href="{{ as_url(get.release.finished, project_name=(project.name|string)) }}"
class="btn btn-outline-primary">
<i class="bi bi-folder2-open me-1"></i> Finished releases (<code>{{ count }}</code>)
</a>
diff --git a/atr/templates/report-selected-path.html b/atr/templates/report-selected-path.html
index 94ad614f..2186cb59 100644
--- a/atr/templates/report-selected-path.html
+++ b/atr/templates/report-selected-path.html
@@ -21,10 +21,10 @@
{% set phase = release.phase.value %}
<p class="d-flex justify-content-between align-items-center">
{% if phase == "release_candidate_draft" %}
- <a href="{{ as_url(get.compose.selected, project_name=release.project.name, version_name=release.version) }}"
+ <a href="{{ as_url(get.compose.selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
class="atr-back-link">← Back to Compose {{ release.project.short_display_name }} {{ release.version }}</a>
{% else %}
- <a href="{{ as_url(get.vote.selected, project_name=release.project.name, version_name=release.version) }}"
+ <a href="{{ as_url(get.vote.selected, project_name=str(release.project.name), version_name=str(release.version)) }}"
class="atr-back-link">← Back to Vote on {{ release.project.short_display_name }} {{ release.version }}</a>
{% endif %}
<span class="atr-phase-nav">
@@ -111,7 +111,7 @@
<tr class="atr-result-primary atr-result-status-{{ primary_result.status.value }} {% if primary_result.status.value == 'success' and not all_primary_are_success %}atr-hide{% endif %}">
<th scope="row" class="align-middle fw-bold">
<a class="atr-link-plain"
- href="{{ as_url(get.result.data, project_name=project_name, version_name=version_name, check_id=primary_result.id) }}">
+ href="{{ as_url(get.result.data, project_name=str(project_name), version_name=str(version_name), check_id=primary_result.id) }}">
{{ function_name_from_key(primary_result.checker) }}
</a>
</th>
@@ -298,7 +298,7 @@
<td class="align-middle">{{ member_rel_path }}</td>
<th scope="row" class="align-middle fw-bold">
<a class="atr-link-plain"
- href="{{ as_url(get.result.data, project_name=project_name, version_name=version_name, check_id=member_result.id) }}">
+ href="{{ as_url(get.result.data, project_name=str(project_name), version_name=str(version_name), check_id=member_result.id) }}">
{{ function_name_from_key(member_result.checker) }}
</a>
</th>
diff --git a/atr/templates/resolve-tabulated.html b/atr/templates/resolve-tabulated.html
index 843d72c6..8eae1919 100644
--- a/atr/templates/resolve-tabulated.html
+++ b/atr/templates/resolve-tabulated.html
@@ -6,7 +6,7 @@
{% block content %}
<p>
- <a href="{{ as_url(get.vote.selected, project_name=release.project.name, version_name=release.version) }}"
+ <a href="{{ as_url(get.vote.selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
class="atr-back-link">← Back to Vote for {{ release.short_display_name }}</a>
</p>
diff --git a/atr/validate.py b/atr/validate.py
index 7688f823..cb2ed305 100644
--- a/atr/validate.py
+++ b/atr/validate.py
@@ -80,7 +80,7 @@ if True:
yield from divergences_with_annotations(
components,
original.__name__,
- p.name,
+ str(p.name),
original(p),
)
@@ -298,7 +298,7 @@ def release_components(
yield from divergences_with_annotations(
components,
original.__name__,
- r.name,
+ str(r.name),
original(r),
)
diff --git a/atr/web.py b/atr/web.py
index ce2a4656..66671007 100644
--- a/atr/web.py
+++ b/atr/web.py
@@ -89,7 +89,7 @@ class Committer:
return user.is_admin(self.uid)
async def check_access(self, project_name: str | safe.ProjectName) -> None:
- if not any((p.name == str(project_name)) for p in (await self.user_projects)):
+ if not any((str(p.name) == str(project_name)) for p in (await self.user_projects)):
if self.is_admin:
# Admins can view all projects
# But we must warn them when the project is not one of their own
@@ -162,8 +162,8 @@ class Committer:
async def release(
self,
- project_name: str,
- version_name: str,
+ project_name: safe.ProjectName,
+ version_name: safe.VersionName,
phase: sql.ReleasePhase | db.NotSet | None = db.NOT_SET,
latest_revision_number: str | db.NotSet | None = db.NOT_SET,
data: db.Session | None = None,
@@ -182,11 +182,11 @@ class Committer:
phase_value = sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
else:
phase_value = phase
- release_name = sql.release_name(str(project_name), str(version_name))
+ release_name = sql.release_name(project_name, version_name)
if data is None:
async with db.session() as data:
release = await data.release(
- name=release_name,
+ name=str(release_name),
phase=phase_value,
latest_revision_number=latest_revision_number,
_committee=with_committee,
@@ -198,7 +198,7 @@ class Committer:
).demand(base.ASFQuartException("Release does not exist", errorcode=404))
else:
release = await data.release(
- name=release_name,
+ name=str(release_name),
phase=phase_value,
latest_revision_number=latest_revision_number,
_committee=with_committee,
diff --git a/atr/worker.py b/atr/worker.py
index ac19a940..358a2bcc 100644
--- a/atr/worker.py
+++ b/atr/worker.py
@@ -38,6 +38,7 @@ import atr.db as db
import atr.ldap as ldap
import atr.log as log
import atr.models.results as results
+import atr.models.safe as safe
import atr.models.sql as sql
import atr.tasks as tasks
import atr.tasks.checks as checks
@@ -118,12 +119,16 @@ async def _execute_check_task(
f"Task {task_id} ({task_type}) has non-dict raw args {task_args} which should represent keyword_args"
)
+ project_name = safe.ProjectName(task_obj.project_name)
+ version_name = safe.VersionName(task_obj.version_name)
+
+ # TODO: The recorder needs values but what do we do if the task doesn't have a project name?
async def recorder_factory() -> checks.Recorder:
return await checks.Recorder.create(
checker=handler,
inputs_hash=task_obj.inputs_hash or "",
- project_name=task_obj.project_name or "",
- version_name=task_obj.version_name or "",
+ project_name=project_name or safe.ProjectName(""),
+ version_name=version_name or safe.VersionName(""),
revision_number=task_obj.revision_number or "",
primary_rel_path=task_obj.primary_rel_path,
)
@@ -131,8 +136,8 @@ async def _execute_check_task(
function_arguments = checks.FunctionArguments(
recorder=recorder_factory,
asf_uid=task_obj.asf_uid,
- project_name=task_obj.project_name or "",
- version_name=task_obj.version_name or "",
+ project_name=project_name or safe.ProjectName(""),
+ version_name=version_name or safe.VersionName(""),
revision_number=task_obj.revision_number,
primary_rel_path=task_obj.primary_rel_path,
extra_args=task_args,
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@tooling.apache.org
For additional commands, e-mail: commits-help@tooling.apache.org