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