You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tooling.apache.org by sb...@apache.org on 2026/07/10 19:50:44 UTC
(tooling-trusted-releases) branch sbp updated: Ensure that only PMC members and committer RMs can publish to SVN
This is an automated email from the ASF dual-hosted git repository.
sbp pushed a commit to branch sbp
in repository https://gitbox.apache.org/repos/asf/tooling-trusted-releases.git
The following commit(s) were added to refs/heads/sbp by this push:
new 5289b06d Ensure that only PMC members and committer RMs can publish to SVN
5289b06d is described below
commit 5289b06dff3bf9f2e31490f33230ad0e9fcbdd56
Author: Sean B. Palmer <se...@miscoranda.com>
AuthorDate: Fri Jul 10 20:49:32 2026 +0100
Ensure that only PMC members and committer RMs can publish to SVN
---
atr/get/finish.py | 5 +-
atr/post/finish.py | 4 +-
atr/storage/writers/release.py | 276 +++++++++++++++++-----------------
atr/tasks/svnpub.py | 4 +-
tests/unit/test_svn_publish_writer.py | 12 +-
5 files changed, 152 insertions(+), 149 deletions(-)
diff --git a/atr/get/finish.py b/atr/get/finish.py
index e9fe1ed5..314c302d 100644
--- a/atr/get/finish.py
+++ b/atr/get/finish.py
@@ -253,7 +253,10 @@ async def _render_page(
page.append(_render_dist_warning())
page.append(_render_distribution_buttons(release))
- if config.get().SVN_PUBLISH_URL:
+ if config.get().SVN_PUBLISH_URL and (
+ user.is_committee_member(release.committee, session.uid)
+ or user.is_release_manager(release.committee, session.uid)
+ ):
proj, ver, rev = release.safe_project_key, release.safe_version_key, release.safe_latest_revision_number
in_flight = await interaction.release_in_flight_svn_publish_task(proj, ver, rev)
completed = await interaction.release_completed_svn_publish_task_for_revision(proj, ver, rev)
diff --git a/atr/post/finish.py b/atr/post/finish.py
index d5b2aaad..cf3d60e8 100644
--- a/atr/post/finish.py
+++ b/atr/post/finish.py
@@ -40,8 +40,8 @@ async def selected(
respond = _respond_helper(session, project_key, version_key)
try:
async with storage.write(session) as write:
- wacp = await write.as_project_committee_participant(project_key)
- await wacp.release.publish_to_svn(
+ warm = await write.as_project_release_manager(project_key)
+ await warm.release.publish_to_svn(
project_key, version_key, publish_form.revision_number, publish_form.download_path_suffix
)
except storage.AccessError as e:
diff --git a/atr/storage/writers/release.py b/atr/storage/writers/release.py
index 4299d545..8d678afe 100644
--- a/atr/storage/writers/release.py
+++ b/atr/storage/writers/release.py
@@ -783,144 +783,6 @@ class CommitteeParticipant(FoundationCommitter):
return str(e), moved_files_names, skipped_files_names
return None, moved_files_names, skipped_files_names
- async def publish_to_svn(
- self,
- project_key: safe.ProjectKey,
- version_key: safe.VersionKey,
- expected_revision: safe.RevisionNumber,
- download_path_suffix: safe.RelPath | None,
- *,
- publisher_asf_uid: str | None = None,
- ) -> sql.Task:
- release = await self.__data.release(
- project_key=str(project_key),
- version=str(version_key),
- phase=sql.ReleasePhase.RELEASE_PREVIEW,
- _project=True,
- _committee=True,
- ).demand(
- storage.AccessError(
- f"Release preview {project_key!s} {version_key!s} does not exist",
- status=404,
- )
- )
- storage.ensure_project_active(release.project)
- self.__write.ensure_release_writable(release)
- committee = release.project.committee
- if committee is None:
- raise storage.AccessError("Release has no committee - Invalid state", status=500)
- task_asf_uid = publisher_asf_uid or self.__asf_uid
- try:
- util.svn_publish_target()
- util.svn_publish_internal_url(committee, download_path_suffix)
- except ValueError as exc:
- raise storage.AccessError(f"SVN publish URL is not acceptable: {exc}", status=409) from exc
- await self.__data.begin_immediate()
- try:
- via = sql.validate_instrumented_attribute
- latest_stmt = (
- sqlmodel.select(sql.Revision.number)
- .where(via(sql.Revision.release_key) == release.key)
- .order_by(via(sql.Revision.seq).desc())
- .limit(1)
- )
- latest_revision_number = (await self.__data.execute(latest_stmt)).scalar_one_or_none()
- if latest_revision_number is None:
- raise storage.AccessError("Release has no revisions - Invalid state", status=500)
- if latest_revision_number != str(expected_revision):
- raise storage.AccessError("A newer revision appeared, please refresh and try again.", status=409)
- existing_in_flight = await interaction.release_in_flight_svn_publish_task(
- project_key, version_key, expected_revision, caller_data=self.__data
- )
- if existing_in_flight is not None:
- raise storage.AccessError(
- "An SVN publish task is already queued or running for this revision", status=409
- )
- existing_completed_any_target = await interaction.release_completed_svn_publish_task_for_revision(
- project_key, version_key, expected_revision, caller_data=self.__data
- )
- if existing_completed_any_target is not None:
- raise storage.AccessError("An SVN publish task already completed for this revision", status=409)
- task = sql.Task(
- status=sql.TaskStatus.QUEUED,
- task_type=sql.TaskType.SVN_PUBLISH,
- task_args=args.SvnPublish(
- asf_uid=task_asf_uid,
- project_key=project_key,
- version_key=version_key,
- revision_number=expected_revision,
- download_path_suffix=download_path_suffix,
- ).model_dump(),
- asf_uid=task_asf_uid,
- project_key=str(project_key),
- version_key=str(version_key),
- revision_number=str(expected_revision),
- )
- self.__data.add(task)
- await self.__data.commit()
- except storage.AccessError:
- await self.__data.rollback()
- raise
- except Exception:
- await self.__data.rollback()
- raise
- self.__write_as.append_to_audit_log(
- asf_uid=task_asf_uid,
- project_key=str(project_key),
- version_key=str(version_key),
- revision_number=str(expected_revision),
- )
- return task
-
- async def publish_to_svn_execute(self, task_args: args.SvnPublish) -> results.SvnPublish:
- release = await self.__data.release(
- project_key=str(task_args.project_key),
- version=str(task_args.version_key),
- phase=sql.ReleasePhase.RELEASE_PREVIEW,
- _project=True,
- _committee=True,
- ).demand(datatypes.FailedError("Release preview not found for publish"))
- storage.ensure_project_active(release.project)
- committee = release.project.committee
- if committee is None:
- raise datatypes.FailedError("Release has no committee - Invalid state")
- latest_revision = release.safe_latest_revision_number
- if latest_revision != task_args.revision_number:
- raise datatypes.FailedError("A newer revision appeared after queuing this publish task")
- try:
- internal_url = util.svn_publish_internal_url(committee, task_args.download_path_suffix)
- except ValueError as exc:
- raise datatypes.FailedError(f"SVN publish URL is not acceptable: {exc}") from exc
- preview_path = paths.release_directory(release)
- log_message = (
- f"Publish {task_args.project_key!s}-{task_args.version_key!s}\n\n"
- f"Committee: {committee.key}\n"
- f"Project: {task_args.project_key!s}\n"
- f"Version: {task_args.version_key!s}\n"
- "Tool: ATR\n"
- f"Released by {task_args.asf_uid} via ATR"
- )
-
- try:
- revision = await svn.publish_release(preview_path.path, internal_url, task_args.asf_uid, log_message)
- except svn.CommandExecutionError as exc:
- log.error("SVN publish failed")
- if "E160020" in exc.output:
- message = "Release file already exists in SVN"
- if (match := re.search(r"path '([^']+)'", exc.output)) is not None:
- message = f"{message}: {match.group(1)}"
- if svn_publish_url := config.get().SVN_PUBLISH_URL:
- message = message.replace(svn_publish_url, "")
- raise datatypes.FailedError(message) from exc
- raise datatypes.FailedError("SVN publish failed; see worker logs for details") from exc
- if revision is None:
- raise datatypes.FailedError("SVN publish did not return a Committed revision line")
- return results.SvnPublish(
- kind="svn_publish",
- svn_revision=revision,
- message=f"Published to SVN as r{revision}",
- )
-
async def start_vote_no_commit( # noqa: C901
self,
release_key: safe.ReleaseKey,
@@ -1312,6 +1174,144 @@ class ReleaseManager(CommitteeParticipant):
)
return None
+ async def publish_to_svn(
+ self,
+ project_key: safe.ProjectKey,
+ version_key: safe.VersionKey,
+ expected_revision: safe.RevisionNumber,
+ download_path_suffix: safe.RelPath | None,
+ *,
+ publisher_asf_uid: str | None = None,
+ ) -> sql.Task:
+ release = await self.__data.release(
+ project_key=str(project_key),
+ version=str(version_key),
+ phase=sql.ReleasePhase.RELEASE_PREVIEW,
+ _project=True,
+ _committee=True,
+ ).demand(
+ storage.AccessError(
+ f"Release preview {project_key!s} {version_key!s} does not exist",
+ status=404,
+ )
+ )
+ storage.ensure_project_active(release.project)
+ self.__write.ensure_release_writable(release)
+ committee = release.project.committee
+ if committee is None:
+ raise storage.AccessError("Release has no committee - Invalid state", status=500)
+ task_asf_uid = publisher_asf_uid or self.__asf_uid
+ try:
+ util.svn_publish_target()
+ util.svn_publish_internal_url(committee, download_path_suffix)
+ except ValueError as exc:
+ raise storage.AccessError(f"SVN publish URL is not acceptable: {exc}", status=409) from exc
+ await self.__data.begin_immediate()
+ try:
+ via = sql.validate_instrumented_attribute
+ latest_stmt = (
+ sqlmodel.select(sql.Revision.number)
+ .where(via(sql.Revision.release_key) == release.key)
+ .order_by(via(sql.Revision.seq).desc())
+ .limit(1)
+ )
+ latest_revision_number = (await self.__data.execute(latest_stmt)).scalar_one_or_none()
+ if latest_revision_number is None:
+ raise storage.AccessError("Release has no revisions - Invalid state", status=500)
+ if latest_revision_number != str(expected_revision):
+ raise storage.AccessError("A newer revision appeared, please refresh and try again.", status=409)
+ existing_in_flight = await interaction.release_in_flight_svn_publish_task(
+ project_key, version_key, expected_revision, caller_data=self.__data
+ )
+ if existing_in_flight is not None:
+ raise storage.AccessError(
+ "An SVN publish task is already queued or running for this revision", status=409
+ )
+ existing_completed_any_target = await interaction.release_completed_svn_publish_task_for_revision(
+ project_key, version_key, expected_revision, caller_data=self.__data
+ )
+ if existing_completed_any_target is not None:
+ raise storage.AccessError("An SVN publish task already completed for this revision", status=409)
+ task = sql.Task(
+ status=sql.TaskStatus.QUEUED,
+ task_type=sql.TaskType.SVN_PUBLISH,
+ task_args=args.SvnPublish(
+ asf_uid=task_asf_uid,
+ project_key=project_key,
+ version_key=version_key,
+ revision_number=expected_revision,
+ download_path_suffix=download_path_suffix,
+ ).model_dump(),
+ asf_uid=task_asf_uid,
+ project_key=str(project_key),
+ version_key=str(version_key),
+ revision_number=str(expected_revision),
+ )
+ self.__data.add(task)
+ await self.__data.commit()
+ except storage.AccessError:
+ await self.__data.rollback()
+ raise
+ except Exception:
+ await self.__data.rollback()
+ raise
+ self.__write_as.append_to_audit_log(
+ asf_uid=task_asf_uid,
+ project_key=str(project_key),
+ version_key=str(version_key),
+ revision_number=str(expected_revision),
+ )
+ return task
+
+ async def publish_to_svn_execute(self, task_args: args.SvnPublish) -> results.SvnPublish:
+ release = await self.__data.release(
+ project_key=str(task_args.project_key),
+ version=str(task_args.version_key),
+ phase=sql.ReleasePhase.RELEASE_PREVIEW,
+ _project=True,
+ _committee=True,
+ ).demand(datatypes.FailedError("Release preview not found for publish"))
+ storage.ensure_project_active(release.project)
+ committee = release.project.committee
+ if committee is None:
+ raise datatypes.FailedError("Release has no committee - Invalid state")
+ latest_revision = release.safe_latest_revision_number
+ if latest_revision != task_args.revision_number:
+ raise datatypes.FailedError("A newer revision appeared after queuing this publish task")
+ try:
+ internal_url = util.svn_publish_internal_url(committee, task_args.download_path_suffix)
+ except ValueError as exc:
+ raise datatypes.FailedError(f"SVN publish URL is not acceptable: {exc}") from exc
+ preview_path = paths.release_directory(release)
+ log_message = (
+ f"Publish {task_args.project_key!s}-{task_args.version_key!s}\n\n"
+ f"Committee: {committee.key}\n"
+ f"Project: {task_args.project_key!s}\n"
+ f"Version: {task_args.version_key!s}\n"
+ "Tool: ATR\n"
+ f"Released by {task_args.asf_uid} via ATR"
+ )
+
+ try:
+ revision = await svn.publish_release(preview_path.path, internal_url, task_args.asf_uid, log_message)
+ except svn.CommandExecutionError as exc:
+ log.error("SVN publish failed")
+ if "E160020" in exc.output:
+ message = "Release file already exists in SVN"
+ if (match := re.search(r"path '([^']+)'", exc.output)) is not None:
+ message = f"{message}: {match.group(1)}"
+ if svn_publish_url := config.get().SVN_PUBLISH_URL:
+ message = message.replace(svn_publish_url, "")
+ raise datatypes.FailedError(message) from exc
+ raise datatypes.FailedError("SVN publish failed; see worker logs for details") from exc
+ if revision is None:
+ raise datatypes.FailedError("SVN publish did not return a Committed revision line")
+ return results.SvnPublish(
+ kind="svn_publish",
+ svn_revision=revision,
+ message=f"Published to SVN as r{revision}",
+ )
+
class CommitteeMember(ReleaseManager):
def __init__(
diff --git a/atr/tasks/svnpub.py b/atr/tasks/svnpub.py
index 923b2218..94fbbd44 100644
--- a/atr/tasks/svnpub.py
+++ b/atr/tasks/svnpub.py
@@ -24,5 +24,5 @@ import atr.tasks.checks as checks
@checks.with_model(args.SvnPublish)
async def publish(task_args: args.SvnPublish) -> results.Results | None:
async with storage.write(task_args.asf_uid) as write:
- wacp = await write.as_project_committee_participant(task_args.project_key)
- return await wacp.release.publish_to_svn_execute(task_args)
+ warm = await write.as_project_release_manager(task_args.project_key)
+ return await warm.release.publish_to_svn_execute(task_args)
diff --git a/tests/unit/test_svn_publish_writer.py b/tests/unit/test_svn_publish_writer.py
index 8136aae9..49852f51 100644
--- a/tests/unit/test_svn_publish_writer.py
+++ b/tests/unit/test_svn_publish_writer.py
@@ -281,12 +281,12 @@ def _publish_task(*, status: sql.TaskStatus) -> sql.Task:
)
-def _release_writer(data: db.Session) -> release_writer.CommitteeParticipant:
- writer = object.__new__(release_writer.CommitteeParticipant)
- writer._CommitteeParticipant__asf_uid = "alice"
- writer._CommitteeParticipant__data = data
- writer._CommitteeParticipant__write_as = SimpleNamespace(append_to_audit_log=mock.Mock())
- writer._CommitteeParticipant__write = mock.MagicMock()
+def _release_writer(data: db.Session) -> release_writer.ReleaseManager:
+ writer = object.__new__(release_writer.ReleaseManager)
+ writer._ReleaseManager__asf_uid = "alice"
+ writer._ReleaseManager__data = data
+ writer._ReleaseManager__write_as = SimpleNamespace(append_to_audit_log=mock.Mock())
+ writer._ReleaseManager__write = mock.MagicMock()
return writer
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@tooling.apache.org
For additional commands, e-mail: commits-help@tooling.apache.org