comparison mercurial/changegroup.py @ 38997:812eec3f89cb

changegroup: remove _clnodetorev

cgpacker._clnodetorev is a glorified cache/index of changelog
nodes to revision numbers.

I'm not sure why it exists. Maybe performance? But its presence
is making refactoring of this code more complicated than it needs
to be.

This commit removes the cache and replaces it with direct lookups
against the changelog.

If this cache was for performance reasons, we should be able to
restore it easily enough... after the changegroup refactor is
complete.

Differential Revision: https://phab.mercurial-scm.org/D4189

38996:5baafb8fe253

        dag = dagutil.revlogdag(store)
        return dag.linearize(set(store.rev(n) for n in nodes))
    else:
        return sorted([store.rev(n) for n in nodes])

def _sortnodesellipsis(store, nodes, clnodetorev, lookup):
    """Sort nodes for changegroup generation and turn into revnums."""
    # Ellipses serving mode.
    #
    # In a perfect world, we'd generate better ellipsis-ified graphs
    # for non-changelog revlogs. In practice, we haven't started doing

    # The one invariant we *know* holds is that the new (potentially
    # bogus) DAG shape will be valid if we order the nodes in the
    # order that they're introduced in dramatis personae by the
    # changelog, so what we do is we sort the non-changelog histories
    # by the order in which they are used by the changelog.
    key = lambda n: clnodetorev[lookup(n)]
    return [store.rev(n) for n in sorted(nodes, key=key)]

def _revisiondeltanormal(store, rev, prev, linknode, deltaparentfn):
    """Construct a revision delta for non-ellipses changegroup generation."""
    node = store.node(rev)

        # Maps CL revs to per-revlog revisions. Cleared in close() at
        # the end of each group.
        self._clrevtolocalrev = {}
        self._nextclrevtolocalrev = {}

        # Maps changelog nodes to changelog revs. Filled in once
        # during changelog stage and then left unmodified.
        self._clnodetorev = {}

    def _close(self):
        # Ellipses serving mode.
        self._clrevtolocalrev.clear()
        if self._nextclrevtolocalrev is not None:
            self._clrevtolocalrev = self._nextclrevtolocalrev

        """
        # if we don't have any revisions touched by these changesets, bail
        if len(revs) == 0:
            yield self._close()
            return

        # add the parent of the first rev
        p = store.parentrevs(revs[0])[0]
        revs.insert(0, p)

                progress.update(r + 1)
            prev, curr = revs[r], revs[r + 1]
            linknode = lookup(store.node(curr))

            if self._ellipses:
                linkrev = self._clnodetorev[linknode]
                self._clrevtolocalrev[linkrev] = curr

                # This is a node to send in full, because the changeset it
                # corresponds to was a full changeset.
                if linknode in self._fullclnodes:

        def lookupcl(x):
            c = cl.read(x)
            clrevorder[x] = len(clrevorder)

            if self._ellipses:
                self._clnodetorev[x] = cl.rev(x)

                # Only update mfs if x is going to be sent. Otherwise we
                # end up with bogus linkrevs specified for manifests and
                # we skip some manifest nodes that we should otherwise
                # have sent.
                if (x in self._fullclnodes

        `source` is unused here, but is used by extensions like remotefilelog to
        change what is sent based in pulls vs pushes, etc.
        """
        repo = self._repo
        mfl = repo.manifestlog
        dirlog = mfl._revlog.dirlog
        tmfnodes = {'': mfs}

        # Callback for the manifest, used to collect linkrevs for filelog

            prunednodes = self._prune(store, nodes, commonrevs)
            if not dir or prunednodes:
                lookupfn = makelookupmflinknode(dir, nodes)

                if self._ellipses:
                    revs = _sortnodesellipsis(store, prunednodes,
                                              self._clnodetorev, lookupfn)
                else:
                    revs = _sortnodesnormal(store, prunednodes,
                                            self._reorder)

                for x in self._packmanifests(dir, store, revs, lookupfn):

        return self._generatefiles(changedfiles, linknodes, commonrevs, source)

    def _generatefiles(self, changedfiles, linknodes, commonrevs, source):
        repo = self._repo
        progress = repo.ui.makeprogress(_('bundling'), unit=_('files'),
                                        total=len(changedfiles))
        for i, fname in enumerate(sorted(changedfiles)):
            filerevlog = repo.file(fname)
            if not filerevlog:

            filenodes = self._prune(filerevlog, linkrevnodes, commonrevs)
            if filenodes:
                if self._ellipses:
                    revs = _sortnodesellipsis(filerevlog, filenodes,
                                              self._clnodetorev, lookupfilelog)
                else:
                    revs = _sortnodesnormal(filerevlog, filenodes,
                                            self._reorder)

                progress.update(i + 1, item=fname)

            """
            if clrev == nullrev:
                return nullrev

            if ischangelog:
                # If we're doing the changelog, it's possible that we
                # have a parent that is already on the client, and we
                # need to store some extra mapping information so that
                # our contained ellipsis nodes will be able to resolve
                # their parents.
                if clrev not in self._clrevtolocalrev:
                    clnode = store.node(clrev)
                    self._clnodetorev[clnode] = clrev
                return clrev

            # Walk the ellipsis-ized changelog breadth-first looking for a
            # change that has been linked from the current revlog.
            #

38997:812eec3f89cb

        dag = dagutil.revlogdag(store)
        return dag.linearize(set(store.rev(n) for n in nodes))
    else:
        return sorted([store.rev(n) for n in nodes])

def _sortnodesellipsis(store, nodes, cl, lookup):
    """Sort nodes for changegroup generation and turn into revnums."""
    # Ellipses serving mode.
    #
    # In a perfect world, we'd generate better ellipsis-ified graphs
    # for non-changelog revlogs. In practice, we haven't started doing

    # The one invariant we *know* holds is that the new (potentially
    # bogus) DAG shape will be valid if we order the nodes in the
    # order that they're introduced in dramatis personae by the
    # changelog, so what we do is we sort the non-changelog histories
    # by the order in which they are used by the changelog.
    key = lambda n: cl.rev(lookup(n))
    return [store.rev(n) for n in sorted(nodes, key=key)]

def _revisiondeltanormal(store, rev, prev, linknode, deltaparentfn):
    """Construct a revision delta for non-ellipses changegroup generation."""
    node = store.node(rev)

        # Maps CL revs to per-revlog revisions. Cleared in close() at
        # the end of each group.
        self._clrevtolocalrev = {}
        self._nextclrevtolocalrev = {}

    def _close(self):
        # Ellipses serving mode.
        self._clrevtolocalrev.clear()
        if self._nextclrevtolocalrev is not None:
            self._clrevtolocalrev = self._nextclrevtolocalrev

        """
        # if we don't have any revisions touched by these changesets, bail
        if len(revs) == 0:
            yield self._close()
            return

        cl = self._repo.changelog

        # add the parent of the first rev
        p = store.parentrevs(revs[0])[0]
        revs.insert(0, p)

                progress.update(r + 1)
            prev, curr = revs[r], revs[r + 1]
            linknode = lookup(store.node(curr))

            if self._ellipses:
                linkrev = cl.rev(linknode)
                self._clrevtolocalrev[linkrev] = curr

                # This is a node to send in full, because the changeset it
                # corresponds to was a full changeset.
                if linknode in self._fullclnodes:

        def lookupcl(x):
            c = cl.read(x)
            clrevorder[x] = len(clrevorder)

            if self._ellipses:
                # Only update mfs if x is going to be sent. Otherwise we
                # end up with bogus linkrevs specified for manifests and
                # we skip some manifest nodes that we should otherwise
                # have sent.
                if (x in self._fullclnodes

        `source` is unused here, but is used by extensions like remotefilelog to
        change what is sent based in pulls vs pushes, etc.
        """
        repo = self._repo
        cl = repo.changelog
        mfl = repo.manifestlog
        dirlog = mfl._revlog.dirlog
        tmfnodes = {'': mfs}

        # Callback for the manifest, used to collect linkrevs for filelog

            prunednodes = self._prune(store, nodes, commonrevs)
            if not dir or prunednodes:
                lookupfn = makelookupmflinknode(dir, nodes)

                if self._ellipses:
                    revs = _sortnodesellipsis(store, prunednodes, cl,
                                              lookupfn)
                else:
                    revs = _sortnodesnormal(store, prunednodes,
                                            self._reorder)

                for x in self._packmanifests(dir, store, revs, lookupfn):

        return self._generatefiles(changedfiles, linknodes, commonrevs, source)

    def _generatefiles(self, changedfiles, linknodes, commonrevs, source):
        repo = self._repo
        cl = repo.changelog
        progress = repo.ui.makeprogress(_('bundling'), unit=_('files'),
                                        total=len(changedfiles))
        for i, fname in enumerate(sorted(changedfiles)):
            filerevlog = repo.file(fname)
            if not filerevlog:

            filenodes = self._prune(filerevlog, linkrevnodes, commonrevs)
            if filenodes:
                if self._ellipses:
                    revs = _sortnodesellipsis(filerevlog, filenodes,
                                              cl, lookupfilelog)
                else:
                    revs = _sortnodesnormal(filerevlog, filenodes,
                                            self._reorder)

                progress.update(i + 1, item=fname)

            """
            if clrev == nullrev:
                return nullrev

            if ischangelog:
                return clrev

            # Walk the ellipsis-ized changelog breadth-first looking for a
            # change that has been linked from the current revlog.
            #