Method _roster_remove

salt/utils/mmap_cache.py:534–592

Tombstone *slot* in the roster file with an in-place 4-byte overwrite. **Fast path** (same-process delete after a ``put``): the byte offset of the entry was recorded by ``_roster_append`` in ``_roster_slot_offsets``. We seek directly and write the tombstone

(self, slot)

        self._roster_invalidate()

    def _roster_remove(self, slot):
        """
        Tombstone *slot* in the roster file with an in-place 4-byte overwrite.

        **Fast path** (same-process delete after a ``put``): the byte offset
        of the entry was recorded by ``_roster_append`` in
        ``_roster_slot_offsets``.  We seek directly and write the tombstone
        using the persistent write fd — zero extra opens.

        **Slow path** (cross-process or after restart): scan the file for the
        entry and overwrite it.

        ``_roster_read`` skips ``_ROSTER_TOMBSTONE`` entries; they are
        compacted on the next ``atomic_rebuild``.
        """
        tombstone = struct.pack(_ROSTER_ENTRY_FMT, _ROSTER_TOMBSTONE)

        byte_offset = self._roster_slot_offsets.pop(slot, None)
        if byte_offset is not None:
            # Fast path: reuse the write fd, seek to known offset
            wfd = self._roster_wfd_open()
            if wfd is not None:
                try:
                    wfd.seek(byte_offset)
                    wfd.write(tombstone)
                    wfd.flush()
                    _fsync_fd_maybe(wfd.fileno())
                    # seek back to end so next append lands correctly
                    wfd.seek(0, 2)
                    self._roster_invalidate()
                    return
                except OSError as exc:
                    log.error(
                        "Error tombstoning roster (fast) %s: %s",
                        self.roster_path,
                        exc,
                    )
                    try:
                        wfd.close()
                    except OSError:
                        pass
                    self._roster_wfd = None
                    # fall through to slow path

        # Slow path: open+scan+overwrite
        try:
            with salt.utils.files.fopen(self.roster_path, "r+b") as f:
                data = f.read()
                entry = struct.pack(_ROSTER_ENTRY_FMT, slot)
                idx = data.find(entry)
                if idx == -1:
                    return
                f.seek(idx)
                f.write(tombstone)
                f.flush()
                _fsync_fd_maybe(f.fileno())
        except OSError as exc:
            log.error("Error tombstoning roster %s: %s", self.roster_path, exc)