runta-sdk 0.2.3__tar.gz → 0.2.4__tar.gz

{runta_sdk-0.2.3 → runta_sdk-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runta-sdk
-Version: 0.2.3
+Version: 0.2.4
 Summary: Python SDK for Runta runtime management
 Author: Runta
 License-Expression: MIT
@@ -158,8 +158,10 @@ example to ignore FIFOs and device nodes; by default these are rejected.
 Permissions follow `tarfile.data_filter` (including removal of unsafe mode bits
 and ownership). Safe links are preserved where supported; the standard library
 copies archive referents when link creation is unavailable. Unresolvable dangling
-symlinks are skipped on platforms that cannot create them. Use a current Python
-security patch release with safe tar link fallback; missing safety support raises
+symlinks are skipped on platforms that cannot create them, preserving any
+existing entry at that destination. The SDK uses native
+filtered link fallback when available and provides a safe compatibility path on
+older Python patch releases. A build without `tarfile.data_filter` still raises
 an error rather than extracting unsafely. As with standard tar extraction, do not
 allow another process to modify the destination concurrently during extraction.
 

{runta_sdk-0.2.3 → runta_sdk-0.2.4}/README.md

@@ -130,8 +130,10 @@ example to ignore FIFOs and device nodes; by default these are rejected.
 Permissions follow `tarfile.data_filter` (including removal of unsafe mode bits
 and ownership). Safe links are preserved where supported; the standard library
 copies archive referents when link creation is unavailable. Unresolvable dangling
-symlinks are skipped on platforms that cannot create them. Use a current Python
-security patch release with safe tar link fallback; missing safety support raises
+symlinks are skipped on platforms that cannot create them, preserving any
+existing entry at that destination. The SDK uses native
+filtered link fallback when available and provides a safe compatibility path on
+older Python patch releases. A build without `tarfile.data_filter` still raises
 an error rather than extracting unsafely. As with standard tar extraction, do not
 allow another process to modify the destination concurrently during extraction.
 

{runta_sdk-0.2.3 → runta_sdk-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "runta-sdk"
-version = "0.2.3"
+version = "0.2.4"
 description = "Python SDK for Runta runtime management"
 readme = "README.md"
 requires-python = ">=3.10"

{runta_sdk-0.2.3 → runta_sdk-0.2.4}/runta_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runta-sdk
-Version: 0.2.3
+Version: 0.2.4
 Summary: Python SDK for Runta runtime management
 Author: Runta
 License-Expression: MIT
@@ -158,8 +158,10 @@ example to ignore FIFOs and device nodes; by default these are rejected.
 Permissions follow `tarfile.data_filter` (including removal of unsafe mode bits
 and ownership). Safe links are preserved where supported; the standard library
 copies archive referents when link creation is unavailable. Unresolvable dangling
-symlinks are skipped on platforms that cannot create them. Use a current Python
-security patch release with safe tar link fallback; missing safety support raises
+symlinks are skipped on platforms that cannot create them, preserving any
+existing entry at that destination. The SDK uses native
+filtered link fallback when available and provides a safe compatibility path on
+older Python patch releases. A build without `tarfile.data_filter` still raises
 an error rather than extracting unsafely. As with standard tar extraction, do not
 allow another process to modify the destination concurrently during extraction.
 

{runta_sdk-0.2.3 → runta_sdk-0.2.4}/src/runta/_internal/streaming_transfer.py

@@ -9,6 +9,7 @@ import errno
 from contextlib import asynccontextmanager, contextmanager
 import json
 import os
+import posixpath
 import queue
 import socket
 import ssl
@@ -1146,9 +1147,82 @@ def _safe_relative_name(name: str) -> None:
         raise tarfile.FilterError("download archive contains an unsafe path")
 
 
+@contextmanager
+def _preserve_link_destination(targetpath: str):
+    """Keep an existing entry when link creation/fallback produces no output."""
+    target = Path(targetpath)
+    if not os.path.lexists(target):
+        yield
+        return
+    if target.is_dir():
+        raise FileExistsError(
+            f"download member conflicts with destination type: {target}"
+        )
+    # Move the entry, never copy its contents. The backup remains on the same
+    # filesystem, and is restored before a skipped/failed link returns to tarfile.
+    with tempfile.TemporaryDirectory(prefix=".runta-link-", dir=target.parent) as temp:
+        original = Path(temp) / "original"
+        os.replace(target, original)
+        try:
+            yield
+        except BaseException:
+            if not os.path.lexists(target):
+                os.replace(original, target)
+            raise
+        if not os.path.lexists(target):
+            os.replace(original, target)
+            # Avoid tarfile applying hard-link attributes to the restored file
+            # after a referent was excluded by the filter.
+            raise tarfile.ExtractError("link fallback was skipped")
+
+
 class _DirectoryMergeTarFile(tarfile.TarFile):
     """Replace file entries without writing through existing destination aliases."""
 
+    merge_filter: Callable[[tarfile.TarInfo, str], tarfile.TarInfo | None]
+    merge_root: str
+
+    def makelink_with_filter(
+        self,
+        tarinfo: tarfile.TarInfo,
+        targetpath: str,
+        filter_function=None,
+        extraction_root=None,
+    ) -> None:
+        if tarinfo.issym():
+            # Windows symlink targets need native separators when stored in the
+            # reparse point; archive references remain in POSIX form elsewhere.
+            tarinfo = tarinfo.replace(
+                linkname=os.path.normpath(tarinfo.linkname), deep=False
+            )
+        # Backports with this method differ: some filter the referent only,
+        # while others also check its metadata at the copy destination.
+        # Enforce both checks independently of the native implementation.
+        filter_function = (
+            self.merge_filter if filter_function is None else filter_function
+        )
+        extraction_root = (
+            self.merge_root if extraction_root is None else extraction_root
+        )
+        actual_name = os.path.relpath(targetpath, extraction_root).replace(os.sep, "/")
+
+        def guarded_filter(member, destination):
+            filtered = filter_function(member, destination)
+            if filtered is not None:
+                _filter_contents_member(
+                    filtered.replace(name=actual_name, deep=False),
+                    destination,
+                )
+            return filtered
+
+        with _preserve_link_destination(targetpath):
+            super().makelink_with_filter(
+                tarinfo,
+                targetpath,
+                guarded_filter,
+                extraction_root,
+            )
+
     def makefile(self, tarinfo: tarfile.TarInfo, targetpath: str) -> None:
         # Do this at the actual write path, after filtering. A filter can also
         # run for a link fallback's referent, whose path must remain untouched.
@@ -1161,20 +1235,145 @@ class _DirectoryMergeTarFile(tarfile.TarFile):
         super().makefile(tarinfo, targetpath)
 
 
+class _LegacyDirectoryMergeTarFile(_DirectoryMergeTarFile):
+    """Supply filtered link fallback when the interpreter does not provide it."""
+
+    def makelink(self, tarinfo: tarfile.TarInfo, targetpath: str) -> None:
+        with _preserve_link_destination(targetpath):
+            self._make_compat_link(tarinfo, targetpath)
+
+    def _make_compat_link(self, tarinfo: tarfile.TarInfo, targetpath: str) -> None:
+        try:
+            if tarinfo.issym():
+                Path(targetpath).unlink(missing_ok=True)
+                os.symlink(os.path.normpath(tarinfo.linkname), targetpath)
+                return
+            source = os.path.join(self.merge_root, tarinfo.linkname)
+            if os.path.exists(source):
+                Path(targetpath).unlink(missing_ok=True)
+                os.link(source, targetpath)
+                return
+        except (AttributeError, NotImplementedError, OSError):
+            pass
+
+        try:
+            referent = self._find_link_target(tarinfo)
+        except KeyError:
+            if tarinfo.issym():
+                # Match tarfile's nonfatal treatment of an unsupported dangling
+                # symlink, without suppressing filter or I/O errors.
+                raise tarfile.ExtractError(
+                    "unable to resolve link inside archive"
+                ) from None
+            raise tarfile.FilterError(
+                "hard link target is missing from the archive"
+            ) from None
+
+        # The original archive name is needed for further link lookup. Validate
+        # that location through the user filter, then independently validate the
+        # filtered metadata at the actual write path without invoking user code.
+        filtered = self.merge_filter(referent, self.merge_root)
+        if filtered is None:
+            return
+        actual_name = os.path.relpath(targetpath, self.merge_root).replace(os.sep, "/")
+        relocated = _filter_contents_member(
+            filtered.replace(name=actual_name, deep=False),
+            self.merge_root,
+        )
+        filtered = relocated.replace(name=filtered.name, deep=False)
+
+        # Recursive aliases can otherwise recurse indefinitely on old tarfile.
+        active = getattr(self, "_active_link_fallbacks", set())
+        key = (referent.offset, os.path.abspath(targetpath))
+        if key in active:
+            raise tarfile.FilterError(
+                "download archive contains a cyclic link fallback"
+            )
+        self._active_link_fallbacks = active
+        active.add(key)
+        try:
+            # Reuse the seekable tar's file reader and the existing makefile
+            # replacement semantics; no separate link-copy implementation.
+            self._extract_member(filtered, targetpath)
+        finally:
+            active.remove(key)
+
+    def makelink_with_filter(
+        self,
+        tarinfo: tarfile.TarInfo,
+        targetpath: str,
+        filter_function=None,
+        extraction_root=None,
+    ) -> None:
+        # Some vendor builds use the newer dispatcher without a usable native
+        # implementation. Both dispatchers must enter the same guarded path.
+        self.makelink(tarinfo, targetpath)
+
+
+def _filter_contents_member(
+    member: tarfile.TarInfo,
+    destination: str,
+    *,
+    allow_special: bool = False,
+) -> tarfile.TarInfo:
+    """Mandatory checks, also applied at the physical link-copy destination."""
+    _safe_relative_name(member.name)
+    if PurePosixPath(member.name) == PurePosixPath("."):
+        raise tarfile.FilterError("a filter cannot replace the destination root")
+    if member.issym() or member.islnk():
+        link = member.linkname.replace(os.sep, "/")
+        if (
+            PurePosixPath(link).is_absolute()
+            or PureWindowsPath(link).drive
+            or "\\" in link
+            or ":" in link
+            or "\x00" in link
+        ):
+            raise tarfile.FilterError("download archive contains an unsafe link")
+        # Match patched data_filter: collapse internal '..' components before
+        # checking/creating a link. Otherwise a later archive symlink can change
+        # the meaning of a previously accepted dangling link on old Python.
+        member = member.replace(linkname=posixpath.normpath(link), deep=False)
+    if member.isdev() and allow_special:
+        member = copy.copy(member)
+        member.type = tarfile.REGTYPE
+    elif not (member.isreg() or member.isdir() or member.issym() or member.islnk()):
+        # Older data_filter implementations can overlook special files with
+        # mode=None. A callback must not be able to bypass this boundary.
+        raise tarfile.SpecialFileError(member)
+    member = tarfile.data_filter(member, destination)
+    if (member.issym() or member.islnk()) and os.sep != "/":
+        # Keep archive link references in POSIX form even when a native filter
+        # returns Windows separators, so a later fallback can validate them too.
+        member = member.replace(
+            linkname=member.linkname.replace(os.sep, "/"), deep=False
+        )
+    target = Path(destination) / member.name
+    if not allow_special and target.exists() and target.is_dir() != member.isdir():
+        raise FileExistsError(
+            f"download member conflicts with destination type: {target}"
+        )
+    return member
+
+
 def _extract_dir_contents(
     archive_path: Path,
     dst: Path,
     filter: Callable[[tarfile.TarInfo, str], tarfile.TarInfo | None] | None = None,
 ) -> None:
     data_filter = getattr(tarfile, "data_filter", None)
-    if data_filter is None or not hasattr(tarfile.TarFile, "makelink_with_filter"):
+    if data_filter is None:
         raise RuntimeError(
-            "directory content downloads require a security-patched Python "
-            "with tarfile.data_filter and filtered link fallback"
+            "directory content downloads require a Python build with tarfile.data_filter"
         )
     if dst.is_symlink():
         raise tarfile.FilterError("download destination must not be a symbolic link")
-    with _DirectoryMergeTarFile.open(archive_path, "r:", errorlevel=1) as archive:
+    archive_type = (
+        _DirectoryMergeTarFile
+        if callable(getattr(tarfile.TarFile, "makelink_with_filter", None))
+        else _LegacyDirectoryMergeTarFile
+    )
+    with archive_type.open(archive_path, "r:", errorlevel=1) as archive:
         members = archive.getmembers()
         if not members or members[0].name not in {".", "./"} or not members[0].isdir():
             raise _public.ApiError(
@@ -1211,53 +1410,17 @@ def _extract_dir_contents(
         ) -> tarfile.TarInfo | None:
             if member.name == ".":
                 return None  # Do not apply the source root's metadata to dst.
-            _safe_relative_name(member.name)
-            # Check boundaries before invoking user code, but allow the callback
-            # to skip special files before data_filter rejects those file types.
-            if member.issym() or member.islnk():
-                link = member.linkname
-                if (
-                    PurePosixPath(link).is_absolute()
-                    or PureWindowsPath(link).drive
-                    or "\\" in link
-                    or ":" in link
-                    or "\x00" in link
-                ):
-                    raise tarfile.FilterError(
-                        "download archive contains an unsafe link"
-                    )
-            probe = copy.copy(member)
-            if probe.isdev():
-                probe.type = tarfile.REGTYPE
-            data_filter(probe, destination)
+            # Allow callbacks to skip special files, but validate all paths
+            # and link targets before and after user code.
+            _filter_contents_member(member, destination, allow_special=True)
             if filter is not None:
                 member = filter(copy.copy(member), destination)
                 if member is None:
                     return None
-            _safe_relative_name(member.name)
-            if PurePosixPath(member.name) == PurePosixPath("."):
-                raise tarfile.FilterError(
-                    "a filter cannot replace the destination root"
-                )
-            if member.issym() or member.islnk():
-                link = member.linkname
-                if (
-                    PurePosixPath(link).is_absolute()
-                    or PureWindowsPath(link).drive
-                    or "\\" in link
-                    or ":" in link
-                    or "\x00" in link
-                ):
-                    raise tarfile.FilterError(
-                        "download archive contains an unsafe link"
-                    )
-            member = data_filter(member, destination)
-            target = Path(destination) / member.name
-            if target.exists() and target.is_dir() != member.isdir():
-                raise FileExistsError(
-                    f"download member conflicts with destination type: {target}"
-                )
-            return member
+            return _filter_contents_member(member, destination)
+
+        archive.merge_filter = safe_filter
+        archive.merge_root = os.fspath(dst)
 
         # errorlevel=1 (the default) propagates security/I/O failures while
         # allowing stdlib's nonfatal unresolved-link fallback to skip a link.

{runta_sdk-0.2.3 → runta_sdk-0.2.4}/tests/test_download_dir_contents.py

@@ -16,6 +16,23 @@ from runta._internal import streaming_transfer as transfer
 from runta._internal.async_file_io import _AsyncFileIO
 
 
+@pytest.fixture(
+    autouse=True,
+    params=(
+        ["native", "compat"]
+        if callable(getattr(tarfile.TarFile, "makelink_with_filter", None))
+        else ["compat"]
+    ),
+)
+def link_fallback_capability(request, monkeypatch):
+    """Exercise fallback selection on patched hosts as well as real old Python."""
+    if request.param == "compat":
+        monkeypatch.setattr(
+            tarfile.TarFile, "makelink_with_filter", None, raising=False
+        )
+    return request.param
+
+
 def make_archive(path, entries=()):
     """Entries are (name, data/type, linkname), rooted at the remote tar's '.'."""
     with tarfile.open(path, "w") as archive:
@@ -98,7 +115,8 @@ async def test_transfer_merges_and_cleans(tmp_path, monkeypatch, asynchronous, e
     assert all(not path.parent.exists() for path in paths)
 
 
-def test_permissions_and_links(tmp_path):
+@pytest.mark.parametrize("filter", [None, tarfile.data_filter])
+def test_permissions_and_links(tmp_path, filter):
     target = extract(
         tmp_path,
         [
@@ -107,6 +125,7 @@ def test_permissions_and_links(tmp_path):
             ("./nested/sym", tarfile.SYMTYPE, "../data"),
             ("./hard", tarfile.LNKTYPE, "./data"),
         ],
+        filter,
     )
     assert (target / "nested/sym").is_symlink()
     assert (target / "nested/sym").read_bytes() == b"payload"
@@ -385,7 +404,7 @@ def test_remote_command_resolves_top_directory_and_quotes(tmp_path, symlink):
 
 def test_missing_security_support_fails_closed(tmp_path, monkeypatch):
     monkeypatch.delattr(tarfile, "data_filter")
-    with pytest.raises(RuntimeError, match="security-patched"):
+    with pytest.raises(RuntimeError, match="tarfile.data_filter"):
         extract(tmp_path, [("./data", b"payload", "")])
     assert not (tmp_path / "target").exists()
 
@@ -539,3 +558,253 @@ def test_skipped_member_preserves_existing_alias(tmp_path):
     extract(tmp_path, [("./replace", b"new", "")], skip)
     assert (target / "replace").is_symlink()
     assert (target / "keep").read_bytes() == b"original"
+
+
+@pytest.mark.parametrize("rename_referent", [False, True])
+def test_link_fallback_filters_referent_at_actual_destination(
+    tmp_path, monkeypatch, rename_referent
+):
+    outside = tmp_path / "safe"
+    outside.write_text("outside")
+    real_symlink = os.symlink
+
+    def fail_alias(link, destination, *args, **kwargs):
+        if os.path.normpath(link) == os.path.normpath("deep/ref"):
+            raise OSError("force alias to copy its referent")
+        return real_symlink(link, destination, *args, **kwargs)
+
+    def callback(member, destination):
+        if rename_referent and member.name == "deep/ref":
+            return member.replace(name="deep/renamed")
+        return member
+
+    monkeypatch.setattr(os, "symlink", fail_alias)
+    with pytest.raises(tarfile.FilterError):
+        extract(
+            tmp_path,
+            [
+                ("./safe", b"inside", ""),
+                ("./deep/ref", tarfile.SYMTYPE, "../safe"),
+                ("./alias", tarfile.SYMTYPE, "deep/ref"),
+            ],
+            callback,
+        )
+    assert outside.read_text() == "outside"
+    assert not os.path.lexists(tmp_path / "target/alias")
+
+
+def test_later_link_cannot_turn_an_accepted_link_into_an_escape(tmp_path):
+    target = extract(
+        tmp_path,
+        [
+            ("./alias", tarfile.SYMTYPE, "directory/../outside"),
+            ("./directory", tarfile.SYMTYPE, "."),
+        ],
+    )
+    assert (target / "alias").is_symlink()
+    assert (target / "alias").resolve() == target / "outside"
+
+
+def test_callback_cannot_enable_special_files_with_missing_mode(tmp_path):
+    def callback(member, destination):
+        member.mode = None
+        return member
+
+    with pytest.raises(tarfile.SpecialFileError):
+        extract(tmp_path, [("./fifo", tarfile.FIFOTYPE, "")], callback)
+    assert not (tmp_path / "target/fifo").exists()
+
+
+def test_compat_rejects_cyclic_link_copy(tmp_path, monkeypatch):
+    monkeypatch.setattr(tarfile.TarFile, "makelink_with_filter", None, raising=False)
+
+    def unavailable(*args, **kwargs):
+        raise OSError("links prohibited")
+
+    monkeypatch.setattr(os, "symlink", unavailable)
+    with pytest.raises(tarfile.FilterError, match="cyclic"):
+        extract(
+            tmp_path,
+            [
+                ("./a", tarfile.SYMTYPE, "b"),
+                ("./b", tarfile.SYMTYPE, "a"),
+            ],
+        )
+    assert not (tmp_path / "target/a").exists()
+    assert not (tmp_path / "target/b").exists()
+
+
+@pytest.mark.parametrize("alias", ["file", "symlink", "hardlink", "dangling"])
+def test_unsupported_dangling_link_preserves_existing_destination(
+    tmp_path, monkeypatch, alias
+):
+    target = tmp_path / "target"
+    target.mkdir()
+    keep = target / "keep"
+    keep.write_bytes(b"keep")
+    report = target / "report"
+    if alias == "file":
+        report.write_bytes(b"original")
+    elif alias == "hardlink":
+        os.link(keep, report)
+    else:
+        report.symlink_to("old-missing" if alias == "dangling" else "keep")
+    original_stat = report.lstat()
+
+    def unavailable(*args, **kwargs):
+        raise OSError("links prohibited")
+
+    monkeypatch.setattr(os, "symlink", unavailable)
+    extract(
+        tmp_path,
+        [
+            ("./report", tarfile.SYMTYPE, "new-missing"),
+            ("./last", b"last", ""),
+        ],
+    )
+    assert os.path.lexists(report)
+    assert report.lstat().st_mode == original_stat.st_mode
+    assert keep.read_bytes() == b"keep"
+    if alias == "file":
+        assert report.read_bytes() == b"original"
+    elif alias == "hardlink":
+        assert os.path.samefile(keep, report)
+    else:
+        assert os.readlink(report) == ("old-missing" if alias == "dangling" else "keep")
+    assert (target / "last").read_bytes() == b"last"
+    assert not list(target.glob(".runta-link-*"))
+
+
+def test_filtered_fallback_preserves_existing_destination_metadata(
+    tmp_path, monkeypatch
+):
+    target = tmp_path / "target"
+    target.mkdir()
+    report = target / "report"
+    report.write_bytes(b"original")
+    report.chmod(0o600)
+    before = report.stat()
+
+    def unavailable(*args, **kwargs):
+        raise OSError("links prohibited")
+
+    def skip_referent(member, destination):
+        return None if member.name == "data" else member
+
+    monkeypatch.setattr(os, "link", unavailable)
+    extract(
+        tmp_path,
+        [
+            ("./data", b"new", ""),
+            ("./report", tarfile.LNKTYPE, "./data"),
+            ("./last", b"last", ""),
+        ],
+        skip_referent,
+    )
+    assert report.read_bytes() == b"original"
+    assert report.stat().st_mode == before.st_mode
+    assert report.stat().st_mtime_ns == before.st_mtime_ns
+    assert (target / "last").read_bytes() == b"last"
+    assert not list(target.glob(".runta-link-*"))
+
+
+@pytest.mark.parametrize("fault", ["filter", "copy"])
+def test_link_fallback_failure_restores_existing_destination(
+    tmp_path, monkeypatch, fault
+):
+    target = tmp_path / "target"
+    target.mkdir()
+    report = target / "report"
+    report.write_bytes(b"original")
+
+    def unavailable(*args, **kwargs):
+        raise OSError("links prohibited")
+
+    def callback(member, destination):
+        if fault == "filter" and member.name == "data":
+            raise ValueError("injected failure")
+        return member
+
+    def failed_copy(*args, **kwargs):
+        raise OSError("injected failure")
+
+    monkeypatch.setattr(os, "symlink", unavailable)
+    if fault == "copy":
+        monkeypatch.setattr(transfer._DirectoryMergeTarFile, "makefile", failed_copy)
+    with pytest.raises(
+        ValueError if fault == "filter" else OSError, match="injected failure"
+    ):
+        extract(
+            tmp_path,
+            [
+                ("./report", tarfile.SYMTYPE, "data"),
+                ("./data", b"new", ""),
+            ],
+            callback,
+        )
+    assert report.read_bytes() == b"original"
+    assert not list(target.glob(".runta-link-*"))
+
+
+@pytest.mark.asyncio
+async def test_cancel_drains_link_replacement_before_restoring_and_cleaning(
+    tmp_path, monkeypatch
+):
+    target = tmp_path / "target"
+    target.mkdir()
+    report = target / "report"
+    report.write_bytes(b"original")
+    entered = threading.Event()
+    release = threading.Event()
+    archives = []
+
+    async def download(*args, **kwargs):
+        archives.append(args[4])
+        await kwargs["_file_io"].run(
+            make_archive,
+            args[4],
+            [
+                ("./report", tarfile.SYMTYPE, "missing"),
+                ("./data", b"payload", ""),
+            ],
+        )
+
+    def unavailable(*args, **kwargs):
+        entered.set()
+        assert release.wait(5)
+        raise OSError("links prohibited")
+
+    monkeypatch.setattr(transfer, "_async_download_archive", download)
+    monkeypatch.setattr(os, "symlink", unavailable)
+    task = asyncio.create_task(
+        transfer.async_download_dir_contents(
+            "http://test",
+            "token",
+            "runtime",
+            "/src",
+            target,
+            timeout=1,
+        )
+    )
+    try:
+
+        async def wait_entered():
+            while not entered.is_set():
+                await asyncio.sleep(0)
+
+        await asyncio.wait_for(wait_entered(), 5)
+        task.cancel()
+        await asyncio.sleep(0)
+        task.cancel()
+        await asyncio.sleep(0)
+        assert not task.done()
+        assert archives[0].exists()
+        assert list(target.glob(".runta-link-*"))
+    finally:
+        release.set()
+        with pytest.raises(asyncio.CancelledError):
+            await task
+    assert report.read_bytes() == b"original"
+    assert (target / "data").read_bytes() == b"payload"
+    assert not list(target.glob(".runta-link-*"))
+    assert not archives[0].parent.exists()