comparison mercurial/changegroup.py @ 38906:0548f696795b

changegroup: move revision maps to cgpacker

And remove the underscores so the variables conform to our
naming convention.

The logic in _close() should be the only thing warranting scrutiny
during review.

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

38905:379d90327861

        # TODO the functionality keyed off of this should probably be
        # controlled via arguments to group() that influence behavior.
        self._changelogdone = False

    def _close(self):
        # Ellipses serving mode.
        getattr(self, '_clrev_to_localrev', {}).clear()
        if getattr(self, '_next_clrev_to_localrev', {}):
            self._clrev_to_localrev = self._next_clrev_to_localrev
            del self._next_clrev_to_localrev
        self._changelogdone = True

        return closechunk()

    def _fileheader(self, fname):

        # 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.
        if util.safehasattr(self, '_full_nodes') and self._clnode_to_rev:
            key = lambda n: self._clnode_to_rev[lookup(n)]
            return [store.rev(n) for n in sorted(nodelist, key=key)]

        # for generaldelta revlogs, we linearize the revs; this will both be
        # much quicker and generate a much smaller bundle
        if (store._generaldelta and self._reorder is None) or self._reorder:

                    mfs.setdefault(n, x)
                    # Set this narrow-specific dict so we have the lowest
                    # manifest revnum to look up for this cl revnum. (Part of
                    # mapping changelog ellipsis parents to manifest ellipsis
                    # parents)
                    self._next_clrev_to_localrev.setdefault(cl.rev(x),
                                                            mfrevlog.rev(n))
                # We can't trust the changed files list in the changeset if the
                # client requested a shallow clone.
                if self._isshallow:
                    changedfiles.update(mfl[c[0]].read().keys())
                else:

            # TODO have caller pass in appropriate function.
            def linknodes(flog, fname):
                for c in commonctxs:
                    try:
                        fnode = c.filenode(fname)
                        self._clrev_to_localrev[c.rev()] = flog.rev(fnode)
                    except error.ManifestLookupError:
                        pass
                links = oldlinknodes(flog, fname)
                if len(links) != len(mfdicts):
                    for mf, lr in mfdicts:

    def _revisiondeltanarrow(self, store, rev, prev, linknode):
        # build up some mapping information that's useful later. See
        # the local() nested function below.
        if not self._changelogdone:
            self._clnode_to_rev[linknode] = rev
            linkrev = rev
            self._clrev_to_localrev[linkrev] = rev
        else:
            linkrev = self._clnode_to_rev[linknode]
            self._clrev_to_localrev[linkrev] = rev

        # This is a node to send in full, because the changeset it
        # corresponds to was a full changeset.
        if linknode in self._full_nodes:
            return self._revisiondeltanormal(store, rev, prev, linknode)

                # 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._clrev_to_localrev:
                    clnode = store.node(clrev)
                    self._clnode_to_rev[clnode] = clrev
                return clrev

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

            # nodes even after ellipsis-izing.
            walk = [clrev]
            while walk:
                p = walk[0]
                walk = walk[1:]
                if p in self._clrev_to_localrev:
                    return self._clrev_to_localrev[p]
                elif p in self._full_nodes:
                    walk.extend([pp for pp in self._repo.changelog.parentrevs(p)
                                    if pp != nullrev])
                elif p in self._precomputed_ellipsis:
                    walk.extend([pp for pp in self._precomputed_ellipsis[p]

    # that should be an ellipsis because for very large histories
    # we expect this to be significantly smaller.
    packer._full_nodes = relevant_nodes
    # Maps ellipsis revs to their roots at the changelog level.
    packer._precomputed_ellipsis = ellipsisroots
    # Maps CL revs to per-revlog revisions. Cleared in close() at
    # the end of each group.
    packer._clrev_to_localrev = {}
    packer._next_clrev_to_localrev = {}
    # Maps changelog nodes to changelog revs. Filled in once
    # during changelog stage and then left unmodified.
    packer._clnode_to_rev = {}

    return packer.generate(common, visitnodes, False, source)

38906:0548f696795b

        # TODO the functionality keyed off of this should probably be
        # controlled via arguments to group() that influence behavior.
        self._changelogdone = False

        # 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:
            self.clrevtolocalrev = self._nextclrevtolocalrev
            self._nextclrevtolocalrev.clear()
        self._changelogdone = True

        return closechunk()

    def _fileheader(self, fname):

        # 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.
        if util.safehasattr(self, '_full_nodes') and self._clnodetorev:
            key = lambda n: self._clnodetorev[lookup(n)]
            return [store.rev(n) for n in sorted(nodelist, key=key)]

        # for generaldelta revlogs, we linearize the revs; this will both be
        # much quicker and generate a much smaller bundle
        if (store._generaldelta and self._reorder is None) or self._reorder:

                    mfs.setdefault(n, x)
                    # Set this narrow-specific dict so we have the lowest
                    # manifest revnum to look up for this cl revnum. (Part of
                    # mapping changelog ellipsis parents to manifest ellipsis
                    # parents)
                    self._nextclrevtolocalrev.setdefault(cl.rev(x),
                                                         mfrevlog.rev(n))
                # We can't trust the changed files list in the changeset if the
                # client requested a shallow clone.
                if self._isshallow:
                    changedfiles.update(mfl[c[0]].read().keys())
                else:

            # TODO have caller pass in appropriate function.
            def linknodes(flog, fname):
                for c in commonctxs:
                    try:
                        fnode = c.filenode(fname)
                        self._clrevtolocalrev[c.rev()] = flog.rev(fnode)
                    except error.ManifestLookupError:
                        pass
                links = oldlinknodes(flog, fname)
                if len(links) != len(mfdicts):
                    for mf, lr in mfdicts:

    def _revisiondeltanarrow(self, store, rev, prev, linknode):
        # build up some mapping information that's useful later. See
        # the local() nested function below.
        if not self._changelogdone:
            self._clnodetorev[linknode] = rev
            linkrev = rev
            self._clrevtolocalrev[linkrev] = rev
        else:
            linkrev = self._clnodetorev[linknode]
            self._clrevtolocalrev[linkrev] = rev

        # This is a node to send in full, because the changeset it
        # corresponds to was a full changeset.
        if linknode in self._full_nodes:
            return self._revisiondeltanormal(store, rev, prev, linknode)

                # 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.
            #

            # nodes even after ellipsis-izing.
            walk = [clrev]
            while walk:
                p = walk[0]
                walk = walk[1:]
                if p in self._clrevtolocalrev:
                    return self._clrevtolocalrev[p]
                elif p in self._full_nodes:
                    walk.extend([pp for pp in self._repo.changelog.parentrevs(p)
                                    if pp != nullrev])
                elif p in self._precomputed_ellipsis:
                    walk.extend([pp for pp in self._precomputed_ellipsis[p]

    # that should be an ellipsis because for very large histories
    # we expect this to be significantly smaller.
    packer._full_nodes = relevant_nodes
    # Maps ellipsis revs to their roots at the changelog level.
    packer._precomputed_ellipsis = ellipsisroots

    return packer.generate(common, visitnodes, False, source)