comparison mercurial/branchmap.py @ 51488:94f821490645

branchcache: change the _delayed flag to an explicit `_dirty` flag

This is more consistent with the logic we use for other object and it open the way to a clearer management of the cache state.

Now, cache are created clean, cache update mark them dirty, writing them on
disk mark them clean again.

51487:1a9bdd0e1c44

        The cache for this repository view is updated  if needed and written on
        disk.

        If a transaction is in progress, the writing is schedule to transaction
        close. See the `BranchMapCache.write_delayed` method.

        This method exist independently of __getitem__ as it is sometime useful
        to signal that we have no intend to use the data in memory yet.
        """
        self.updatecache(repo)

                    return

    def clear(self):
        self._per_filter.clear()

    def write_delayed(self, repo):
        unfi = repo.unfiltered()
        for filtername in repoviewutil.get_ordered_subset():
            cache = self._per_filter.get(filtername)
            if cache is None:
                continue
            if cache._delayed:
                if filtername is None:
                    repo = unfi
                else:
                    repo = unfi.filtered(filtername)
                cache.write(repo)

    ) -> None:
        """hasnode is a function which can be used to verify whether changelog
        has a given node or not. If it's not provided, we assume that every node
        we have exists in changelog"""
        self._filtername = repo.filtername
        self._delayed = False
        if tipnode is None:
            self.tipnode = repo.nullid
        else:
            self.tipnode = tipnode
        self.tiprev = tiprev
        self.filteredhash = filteredhash

        super().__init__(repo=repo, entries=entries, closed_nodes=closednodes)
        # closednodes is a set of nodes that close their branch. If the branch
        # cache has been updated, it may contain nodes that are no longer
        # heads.

            closednodes=set(self._closednodes),
            verify_node=self._verify_node,
        )
        # we copy will likely schedule a write anyway, but that does not seems
        # to hurt to overschedule
        other._delayed = self._delayed
        # also copy information about the current verification state
        other._verifiedbranches = set(self._verifiedbranches)
        return other

    def write(self, repo):

        tr = repo.currenttransaction()
        if not getattr(tr, 'finalized', True):
            # Avoid premature writing.
            #
            # (The cache warming setup by localrepo will update the file later.)
            self._delayed = True
            return
        try:
            filename = self._filename(repo)
            with repo.cachevfs(filename, b"w", atomictemp=True) as f:
                self._write_header(f)

                b'wrote %s with %d labels and %d nodes\n',
                _branchcachedesc(repo),
                len(self._entries),
                nodecount,
            )
            self._delayed = False
        except (IOError, OSError, error.Abort) as inst:
            # Abort may be raised by read only opener, so log and continue
            repo.ui.debug(
                b"couldn't write branch cache: %s\n"
                % stringutil.forcebytestr(inst)

                    self.tipnode = cl.node(tiprev)
                    self.tiprev = tiprev
        self.filteredhash = scmutil.filteredhash(
            repo, self.tiprev, needobsolete=True
        )

        self.write(repo)


class remotebranchcache(_BaseBranchCache):
    """Branchmap info for a remote connection, should not write locally"""

51488:94f821490645

        The cache for this repository view is updated  if needed and written on
        disk.

        If a transaction is in progress, the writing is schedule to transaction
        close. See the `BranchMapCache.write_dirty` method.

        This method exist independently of __getitem__ as it is sometime useful
        to signal that we have no intend to use the data in memory yet.
        """
        self.updatecache(repo)

                    return

    def clear(self):
        self._per_filter.clear()

    def write_dirty(self, repo):
        unfi = repo.unfiltered()
        for filtername in repoviewutil.get_ordered_subset():
            cache = self._per_filter.get(filtername)
            if cache is None:
                continue
            if cache._dirty:
                if filtername is None:
                    repo = unfi
                else:
                    repo = unfi.filtered(filtername)
                cache.write(repo)

    ) -> None:
        """hasnode is a function which can be used to verify whether changelog
        has a given node or not. If it's not provided, we assume that every node
        we have exists in changelog"""
        self._filtername = repo.filtername
        if tipnode is None:
            self.tipnode = repo.nullid
        else:
            self.tipnode = tipnode
        self.tiprev = tiprev
        self.filteredhash = filteredhash
        self._dirty = False

        super().__init__(repo=repo, entries=entries, closed_nodes=closednodes)
        # closednodes is a set of nodes that close their branch. If the branch
        # cache has been updated, it may contain nodes that are no longer
        # heads.

            closednodes=set(self._closednodes),
            verify_node=self._verify_node,
        )
        # we copy will likely schedule a write anyway, but that does not seems
        # to hurt to overschedule
        other._dirty = self._dirty
        # also copy information about the current verification state
        other._verifiedbranches = set(self._verifiedbranches)
        return other

    def write(self, repo):

        tr = repo.currenttransaction()
        if not getattr(tr, 'finalized', True):
            # Avoid premature writing.
            #
            # (The cache warming setup by localrepo will update the file later.)
            return
        try:
            filename = self._filename(repo)
            with repo.cachevfs(filename, b"w", atomictemp=True) as f:
                self._write_header(f)

                b'wrote %s with %d labels and %d nodes\n',
                _branchcachedesc(repo),
                len(self._entries),
                nodecount,
            )
            self._dirty = False
        except (IOError, OSError, error.Abort) as inst:
            # Abort may be raised by read only opener, so log and continue
            repo.ui.debug(
                b"couldn't write branch cache: %s\n"
                % stringutil.forcebytestr(inst)

                    self.tipnode = cl.node(tiprev)
                    self.tiprev = tiprev
        self.filteredhash = scmutil.filteredhash(
            repo, self.tiprev, needobsolete=True
        )
        self._dirty = True
        self.write(repo)


class remotebranchcache(_BaseBranchCache):
    """Branchmap info for a remote connection, should not write locally"""