comparison mercurial/localrepo.py @ 13812:2b70683888b9

changegroup: minor ordering and renaming changes for similarity

This eliminates some needless differences between the two changegroup variants

13811:65c1d309ab91

        cl = self.changelog
        mf = self.manifest
        mfs = {} # needed manifests
        fnodes = {} # needed file nodes

        # can we go through the fast path ?
        heads.sort()
        if heads == sorted(self.heads()):
            return self._changegroup(csets, source)

        # Now that we have all theses utility functions to help out and
        # logically divide up the task, generate the group.
        def gengroup():
            # The set of changed files starts empty.
            changedfiles = set()

            count = [0]
            def clookup(revlog, x):
                c = cl.read(x)
                changedfiles.update(c[3])

        This is much easier than the previous function as we can assume that
        the recipient has any changenode we aren't sending them.

        nodes is the set of nodes to send"""

        self.hook('preoutgoing', throw=True, source=source)

        cl = self.changelog
        revset = set([cl.rev(n) for n in nodes])
        self.changegroupinfo(nodes, source)

        def gennodelst(log):
            for r in log:
                if log.linkrev(r) in revset:
                    yield log.node(r)

        def gengroup():
            '''yield a sequence of changegroup chunks (strings)'''
            # construct a list of all changed files
            changedfiles = set()
            mmfs = {}

            count = [0]
            def clookup(revlog, x):
                c = cl.read(x)
                changedfiles.update(c[3])
                mmfs.setdefault(c[0], x)
                count[0] += 1
                self.ui.progress(_('bundling'), count[0], unit=_('changesets'))
                return x

            for chunk in cl.group(nodes, clookup):
                yield chunk
            efiles = len(changedfiles)
            changecount = count[0]
            self.ui.progress(_('bundling'), None)

            mnfst = self.manifest
            count = [0]
            def mlookup(revlog, x):
                count[0] += 1
                self.ui.progress(_('bundling'), count[0],
                                 unit=_('manifests'), total=changecount)
                return cl.node(revlog.linkrev(revlog.rev(x)))

            for chunk in mnfst.group(gennodelst(mnfst), mlookup):
                yield chunk
            self.ui.progress(_('bundling'), None)

            for idx, fname in enumerate(sorted(changedfiles)):
                filerevlog = self.file(fname)

                            break
                        yield changegroup.chunkheader(len(fname))
                        yield fname
                        first = False
                    yield chunk
            self.ui.progress(_('bundling'), None)

            yield changegroup.closechunk()

            if nodes:
                self.hook('outgoing', node=hex(nodes[0]), source=source)

        return changegroup.unbundle10(util.chunkbuffer(gengroup()), 'UN')

13812:2b70683888b9

        cl = self.changelog
        mf = self.manifest
        mfs = {} # needed manifests
        fnodes = {} # needed file nodes
        changedfiles = set()

        # can we go through the fast path ?
        heads.sort()
        if heads == sorted(self.heads()):
            return self._changegroup(csets, source)

        # Now that we have all theses utility functions to help out and
        # logically divide up the task, generate the group.
        def gengroup():
            # The set of changed files starts empty.

            count = [0]
            def clookup(revlog, x):
                c = cl.read(x)
                changedfiles.update(c[3])

        This is much easier than the previous function as we can assume that
        the recipient has any changenode we aren't sending them.

        nodes is the set of nodes to send"""

        cl = self.changelog
        mf = self.manifest
        mfs = {}
        changedfiles = set()

        self.hook('preoutgoing', throw=True, source=source)
        self.changegroupinfo(nodes, source)

        revset = set([cl.rev(n) for n in nodes])

        def gennodelst(log):
            for r in log:
                if log.linkrev(r) in revset:
                    yield log.node(r)

        def gengroup():
            '''yield a sequence of changegroup chunks (strings)'''
            # construct a list of all changed files

            count = [0]
            def clookup(revlog, x):
                c = cl.read(x)
                changedfiles.update(c[3])
                mfs.setdefault(c[0], x)
                count[0] += 1
                self.ui.progress(_('bundling'), count[0], unit=_('changesets'))
                return x

            for chunk in cl.group(nodes, clookup):
                yield chunk
            efiles = len(changedfiles)
            changecount = count[0]
            self.ui.progress(_('bundling'), None)

            count = [0]
            def mlookup(revlog, x):
                count[0] += 1
                self.ui.progress(_('bundling'), count[0],
                                 unit=_('manifests'), total=changecount)
                return cl.node(revlog.linkrev(revlog.rev(x)))

            for chunk in mf.group(gennodelst(mf), mlookup):
                yield chunk
            self.ui.progress(_('bundling'), None)

            for idx, fname in enumerate(sorted(changedfiles)):
                filerevlog = self.file(fname)

                            break
                        yield changegroup.chunkheader(len(fname))
                        yield fname
                        first = False
                    yield chunk
            yield changegroup.closechunk()
            self.ui.progress(_('bundling'), None)

            if nodes:
                self.hook('outgoing', node=hex(nodes[0]), source=source)

        return changegroup.unbundle10(util.chunkbuffer(gengroup()), 'UN')