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 2025/10/08 18:45:10 UTC

(tooling-trusted-releases) branch main updated: Allow participants to delete releases

This is an automated email from the ASF dual-hosted git repository.

sbp pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tooling-trusted-releases.git


The following commit(s) were added to refs/heads/main by this push:
     new c2874c7  Allow participants to delete releases
c2874c7 is described below

commit c2874c7781daccd51d5fec690bb3565d00b2fcfa
Author: Sean B. Palmer <se...@miscoranda.com>
AuthorDate: Wed Oct 8 19:44:52 2025 +0100

    Allow participants to delete releases
---
 atr/routes/draft.py            |   4 +-
 atr/routes/preview.py          |   2 +-
 atr/storage/writers/release.py | 184 ++++++++++++++++++++---------------------
 3 files changed, 95 insertions(+), 95 deletions(-)

diff --git a/atr/routes/draft.py b/atr/routes/draft.py
index 71b5f60..58dfc2f 100644
--- a/atr/routes/draft.py
+++ b/atr/routes/draft.py
@@ -99,8 +99,8 @@ async def delete(session: route.CommitterSession) -> response.Response:
 
     # Delete the metadata from the database
     async with storage.write(session.uid) as write:
-        wacm = await write.as_project_committee_member(project_name)
-        await wacm.release.delete(
+        wacp = await write.as_project_committee_participant(project_name)
+        await wacp.release.delete(
             project_name, version_name, phase=sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT, include_downloads=False
         )
 
diff --git a/atr/routes/preview.py b/atr/routes/preview.py
index d3c832d..0d9c156 100644
--- a/atr/routes/preview.py
+++ b/atr/routes/preview.py
@@ -102,7 +102,7 @@ async def delete(session: route.CommitterSession) -> response.Response:
 
     # Check that the user has access to the project
     async with storage.write(session.uid) as write:
-        wacp = await write.as_project_committee_member(project_name)
+        wacp = await write.as_project_committee_participant(project_name)
         await wacp.release.delete(
             project_name, version_name, phase=sql.ReleasePhase.RELEASE_PREVIEW, include_downloads=False
         )
diff --git a/atr/storage/writers/release.py b/atr/storage/writers/release.py
index 96ec40f..408b97a 100644
--- a/atr/storage/writers/release.py
+++ b/atr/storage/writers/release.py
@@ -98,6 +98,53 @@ class CommitteeParticipant(FoundationCommitter):
         ) as _creating:
             yield _creating
 
+    async def delete(
+        self,
+        project_name: str,
+        version: str,
+        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, _project=True
+        ).demand(storage.AccessError(f"Release '{project_name} {version}' not found."))
+        release_dir = util.release_directory_base(release)
+
+        # Delete from the database
+        log.info(f"Deleting database records for release: {project_name} {version}")
+        # Cascade should handle this, but we delete manually anyway
+        tasks_to_delete = await self.__data.task(project_name=release.project.name, version_name=release.version).all()
+        for task in tasks_to_delete:
+            await self.__data.delete(task)
+        log.debug(f"Deleted {len(tasks_to_delete)} tasks for {project_name} {version}")
+
+        checks_to_delete = await self.__data.check_result(release_name=release.name).all()
+        for check in checks_to_delete:
+            await self.__data.delete(check)
+        log.debug(f"Deleted {len(checks_to_delete)} check results for {project_name} {version}")
+
+        # TODO: Ensure that revisions are not deleted
+        # But this makes testing difficult
+        # Perhaps delete revisions if associated with test accounts only
+        # But we want to test actual mechanisms, not special case tests
+        # We could create uniquely named releases in tests
+        # Currently part of the discussion in #171, but should be its own issue
+        await self.__data.delete(release)
+        log.info(f"Deleted release record: {project_name} {version}")
+        await self.__data.commit()
+
+        if include_downloads:
+            await self.__delete_release_data_downloads(release)
+        warning = await self.__delete_release_data_filesystem(release_dir, project_name, version)
+        self.__write_as.append_to_audit_log(
+            asf_uid=self.__asf_uid,
+            project_name=project_name,
+            version=version,
+            warning=warning,
+        )
+        return warning
+
     async def delete_empty_directory(
         self, project_name: str, version_name: str, dir_to_delete_rel: pathlib.Path
     ) -> str | None:
@@ -341,6 +388,51 @@ class CommitteeParticipant(FoundationCommitter):
         all_current_paths_interim.sort(key=lambda p: (-len(p.parts), str(p)))
         return all_current_paths_interim
 
+    async def __delete_release_data_downloads(self, release: sql.Release) -> None:
+        # Delete hard links from the downloads directory
+        finished_dir = util.release_directory(release)
+        if await aiofiles.os.path.isdir(finished_dir):
+            release_inodes = set()
+            async for file_path in util.paths_recursive(finished_dir):
+                try:
+                    stat_result = await aiofiles.os.stat(finished_dir / file_path)
+                    release_inodes.add(stat_result.st_ino)
+                except FileNotFoundError:
+                    continue
+
+            if release_inodes:
+                downloads_dir = util.get_downloads_dir()
+                async for link_path in util.paths_recursive(downloads_dir):
+                    full_link_path = downloads_dir / link_path
+                    try:
+                        link_stat = await aiofiles.os.stat(full_link_path)
+                        if link_stat.st_ino in release_inodes:
+                            await aiofiles.os.remove(full_link_path)
+                            log.info(f"Deleted hard link: {full_link_path}")
+                    except FileNotFoundError:
+                        continue
+
+    async def __delete_release_data_filesystem(
+        self, release_dir: pathlib.Path, project_name: str, version: str
+    ) -> str | None:
+        # Delete from the filesystem
+        try:
+            if await aiofiles.os.path.isdir(release_dir):
+                log.info("Deleting filesystem directory: %s", release_dir)
+                # Believe this to be another bug in mypy Protocol handling
+                # TODO: Confirm that this is a bug, and report upstream
+                await aioshutil.rmtree(release_dir)  # type: ignore[call-arg]
+                log.info("Successfully deleted directory: %s", release_dir)
+            else:
+                log.warning("Filesystem directory not found, skipping deletion: %s", release_dir)
+        except Exception as e:
+            log.exception("Error deleting filesystem directory %s:", release_dir)
+            return (
+                f"Database records for '{project_name} {version}' deleted,"
+                f" but failed to delete filesystem directory: {e!s}"
+            )
+        return None
+
     def __related_files(self, path: pathlib.Path) -> list[pathlib.Path]:
         base_path = path.with_suffix("") if (path.suffix in SPECIAL_SUFFIXES) else path
         parent_dir = base_path.parent
@@ -525,98 +617,6 @@ class CommitteeMember(CommitteeParticipant):
         self.__asf_uid = asf_uid
         self.__committee_name = committee_name
 
-    async def delete(
-        self,
-        project_name: str,
-        version: str,
-        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, _project=True
-        ).demand(storage.AccessError(f"Release '{project_name} {version}' not found."))
-        release_dir = util.release_directory_base(release)
-
-        # Delete from the database
-        log.info(f"Deleting database records for release: {project_name} {version}")
-        # Cascade should handle this, but we delete manually anyway
-        tasks_to_delete = await self.__data.task(project_name=release.project.name, version_name=release.version).all()
-        for task in tasks_to_delete:
-            await self.__data.delete(task)
-        log.debug(f"Deleted {len(tasks_to_delete)} tasks for {project_name} {version}")
-
-        checks_to_delete = await self.__data.check_result(release_name=release.name).all()
-        for check in checks_to_delete:
-            await self.__data.delete(check)
-        log.debug(f"Deleted {len(checks_to_delete)} check results for {project_name} {version}")
-
-        # TODO: Ensure that revisions are not deleted
-        # But this makes testing difficult
-        # Perhaps delete revisions if associated with test accounts only
-        # But we want to test actual mechanisms, not special case tests
-        # We could create uniquely named releases in tests
-        # Currently part of the discussion in #171, but should be its own issue
-        await self.__data.delete(release)
-        log.info(f"Deleted release record: {project_name} {version}")
-        await self.__data.commit()
-
-        if include_downloads:
-            await self.__delete_release_data_downloads(release)
-        warning = await self.__delete_release_data_filesystem(release_dir, project_name, version)
-        self.__write_as.append_to_audit_log(
-            asf_uid=self.__asf_uid,
-            project_name=project_name,
-            version=version,
-            warning=warning,
-        )
-        return warning
-
-    async def __delete_release_data_downloads(self, release: sql.Release) -> None:
-        # Delete hard links from the downloads directory
-        finished_dir = util.release_directory(release)
-        if await aiofiles.os.path.isdir(finished_dir):
-            release_inodes = set()
-            async for file_path in util.paths_recursive(finished_dir):
-                try:
-                    stat_result = await aiofiles.os.stat(finished_dir / file_path)
-                    release_inodes.add(stat_result.st_ino)
-                except FileNotFoundError:
-                    continue
-
-            if release_inodes:
-                downloads_dir = util.get_downloads_dir()
-                async for link_path in util.paths_recursive(downloads_dir):
-                    full_link_path = downloads_dir / link_path
-                    try:
-                        link_stat = await aiofiles.os.stat(full_link_path)
-                        if link_stat.st_ino in release_inodes:
-                            await aiofiles.os.remove(full_link_path)
-                            log.info(f"Deleted hard link: {full_link_path}")
-                    except FileNotFoundError:
-                        continue
-
-    async def __delete_release_data_filesystem(
-        self, release_dir: pathlib.Path, project_name: str, version: str
-    ) -> str | None:
-        # Delete from the filesystem
-        try:
-            if await aiofiles.os.path.isdir(release_dir):
-                log.info("Deleting filesystem directory: %s", release_dir)
-                # Believe this to be another bug in mypy Protocol handling
-                # TODO: Confirm that this is a bug, and report upstream
-                await aioshutil.rmtree(release_dir)  # type: ignore[call-arg]
-                log.info("Successfully deleted directory: %s", release_dir)
-            else:
-                log.warning("Filesystem directory not found, skipping deletion: %s", release_dir)
-        except Exception as e:
-            log.exception("Error deleting filesystem directory %s:", release_dir)
-            return (
-                f"Database records for '{project_name} {version}' deleted,"
-                f" but failed to delete filesystem directory: {e!s}"
-            )
-        return None
-
 
 class FoundationAdmin(CommitteeMember):
     def __init__(


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@tooling.apache.org
For additional commands, e-mail: commits-help@tooling.apache.org