Method open

salt/utils/mmap_cache.py:714–814

Open (or re-open after a staleness check) the index mmap. Readers use ACCESS_READ and never acquire the lock. Writers use ACCESS_WRITE and are expected to hold the lock.

(self, write=False)

    # ------------------------------------------------------------------

    def open(self, write=False):
        """
        Open (or re-open after a staleness check) the index mmap.

        Readers use ACCESS_READ and never acquire the lock.
        Writers use ACCESS_WRITE and are expected to hold the lock.
        """
        if self._mm:
            # Check for staleness (Atomic Swap detection).
            need_writable = write and not self._mm_writable
            now = time.monotonic()
            interval = self._staleness_check_interval
            # Only throttle if the existing mapping already satisfies the
            # caller. A read-only mmap can never service a write — we must
            # always tear it down and reopen ACCESS_WRITE, regardless of how
            # recently we last stat()ed.
            if (
                not need_writable
                and interval
                and self._last_staleness_check is not None
                and (now - self._last_staleness_check) < interval
            ):
                return True
            self._last_staleness_check = now
            current_id = self._get_cache_id()
            if current_id != self._cache_id or need_writable:
                # Preserve the persistent lock fd: ``put`` / ``delete`` /
                # ``atomic_rebuild`` call ``open(write=True)`` *while holding*
                # the cross-process flock on ``_lock_fd``. Closing that fd
                # releases the flock as a side effect, letting another writer
                # race the rest of this operation. Use the underscore helper
                # so only mmaps and data fds are reset.
                self._close_mmaps_and_fds()
            else:
                return True

        if write:
            if not self._init_index_file():
                return False
            if not self._init_heap_file():
                return False
            mode = "r+b"
            access = mmap.ACCESS_WRITE
        else:
            if not os.path.exists(self.path):
                return False
            mode = "rb"
            access = mmap.ACCESS_READ

        try:
            # Intentionally long-lived: closed in _close_mmaps_and_fds after mmap
            idx_fp = salt.utils.files.fopen(  # pylint: disable=resource-leakage
                self.path, mode
            )
            try:
                fd = idx_fp.fileno()
                self._cache_id = self._get_cache_id()
                st = os.fstat(fd)