mercurial/localrepo.py

13706:7beb9834d185

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

        # Compute the list of changesets in this changegroup.
        # Some bases may turn out to be superfluous, and some heads may be
        # too.  nodesbetween will return the minimal set of bases and heads
        # necessary to re-create the changegroup.
        if not bases:
            bases = [nullid]
        csets, bases, heads = cl.nodesbetween(bases, heads)

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

        # slow path
        self.hook('preoutgoing', throw=True, source=source)
        self.changegroupinfo(csets, source)

        # We assume that all ancestors of bases are known
        commonrevs = set(cl.ancestors(*[cl.rev(n) for n in bases]))

        # A changeset always belongs to itself, so the changenode lookup
        # function for a changenode is identity.
        def identity(x):
            return x

        # A function generating function that sets up the initial environment
        # the inner function.
        def filenode_collector(changedfiles):
            # This gathers information from each manifestnode included in the

            # so we can include those in the changegroup too.
            #
            # It also remembers which changenode each filenode belongs to.  It
            # does this by assuming the a filenode belongs to the changenode
            # the first manifest that references it belongs to.
            def collect(mannode):
                r = mf.rev(mannode)
                if mf.deltaparent(r) in mf.parentrevs(r):
                    # If the previous rev is one of the parents,
                    # we only need to see a diff.
                    deltamf = mf.readdelta(mannode)
                    # For each line in the delta
                    for f, fnode in deltamf.iteritems():
                        # And if the file is in the list of files we care
                        # about.
                        if f in changedfiles:
                            # Get the changenode this manifest belongs to
                            clnode = mfs[mannode]
                            # Create the set of filenodes for the file if
                            # there isn't one already.
                            ndset = fnodes.setdefault(f, {})
                            # And set the filenode's changelog node to the
                            # manifest's if it hasn't been set already.
                            ndset.setdefault(fnode, clnode)
                else:
                    # Otherwise we need a full manifest.
                    m = mf.read(mannode)
                    # For every file in we care about.
                    for f in changedfiles:
                        fnode = m.get(f, None)
                        # If it's in the manifest
                        if fnode is not None:
                            # See comments above.
                            clnode = mfs[mannode]
                            ndset = fnodes.setdefault(f, {})
                            ndset.setdefault(fnode, clnode)
            return collect

        # If we determine that a particular file or manifest node must be a

            changedfiles = set()
            collect = changegroup.collector(cl, mfs, changedfiles)

            # Create a changenode group generator that will call our functions
            # back to lookup the owning changenode and collect information.
            group = cl.group(csets, identity, collect)
            for cnt, chnk in enumerate(group):
                yield chnk
                # revlog.group yields three entries per node, so
                # dividing by 3 gives an approximation of how many
                # nodes have been processed.

                # If any filenodes are left, generate the group for them,
                # otherwise don't bother.
                if missingfnodes:
                    yield changegroup.chunkheader(len(fname))
                    yield fname
                    # Sort the filenodes by their revision # (topological order)
                    nodeiter = list(missingfnodes)
                    nodeiter.sort(key=filerevlog.rev)
                    # Create a group generator and only pass in a changenode
                    # lookup function as we need to collect no information
                    # from filenodes.
                    group = filerevlog.group(nodeiter,
                                             lambda fnode: missingfnodes[fnode])
                    for chnk in group:
                        # even though we print the same progress on
                        # most loop iterations, put the progress call
                        # here so that time estimates (if any) can be updated
                        self.ui.progress(

13707:296e78744d32

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

        if not bases:
            bases = [nullid]
        csets, bases, heads = cl.nodesbetween(bases, heads)

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

        # slow path
        self.hook('preoutgoing', throw=True, source=source)
        self.changegroupinfo(csets, source)

        # We assume that all ancestors of bases are known
        commonrevs = set(cl.ancestors(*[cl.rev(n) for n in bases]))

        # A function generating function that sets up the initial environment
        # the inner function.
        def filenode_collector(changedfiles):
            # This gathers information from each manifestnode included in the

            # so we can include those in the changegroup too.
            #
            # It also remembers which changenode each filenode belongs to.  It
            # does this by assuming the a filenode belongs to the changenode
            # the first manifest that references it belongs to.
            def collect(mnode):
                r = mf.rev(mnode)
                if mf.deltaparent(r) in mf.parentrevs(r):
                    # If the previous rev is one of the parents,
                    # we only need to see a diff.
                    deltamf = mf.readdelta(mnode)
                    # For each line in the delta
                    for f, fnode in deltamf.iteritems():
                        # And if the file is in the list of files we care
                        # about.
                        if f in changedfiles:
                            # Get the changenode this manifest belongs to
                            clnode = mfs[mnode]
                            # Create the set of filenodes for the file if
                            # there isn't one already.
                            ndset = fnodes.setdefault(f, {})
                            # And set the filenode's changelog node to the
                            # manifest's if it hasn't been set already.
                            ndset.setdefault(fnode, clnode)
                else:
                    # Otherwise we need a full manifest.
                    m = mf.read(mnode)
                    # For every file in we care about.
                    for f in changedfiles:
                        fnode = m.get(f, None)
                        # If it's in the manifest
                        if fnode is not None:
                            # See comments above.
                            clnode = mfs[mnode]
                            ndset = fnodes.setdefault(f, {})
                            ndset.setdefault(fnode, clnode)
            return collect

        # If we determine that a particular file or manifest node must be a

            changedfiles = set()
            collect = changegroup.collector(cl, mfs, changedfiles)

            # Create a changenode group generator that will call our functions
            # back to lookup the owning changenode and collect information.
            group = cl.group(csets, lambda x: x, collect)
            for cnt, chnk in enumerate(group):
                yield chnk
                # revlog.group yields three entries per node, so
                # dividing by 3 gives an approximation of how many
                # nodes have been processed.

                # If any filenodes are left, generate the group for them,
                # otherwise don't bother.
                if missingfnodes:
                    yield changegroup.chunkheader(len(fname))
                    yield fname
                    # Create a group generator and only pass in a changenode
                    # lookup function as we need to collect no information
                    # from filenodes.
                    group = filerevlog.group(
                        sorted(missingfnodes, key=filerevlog.rev),
                        lambda fnode: missingfnodes[fnode])
                    for chnk in group:
                        # even though we print the same progress on
                        # most loop iterations, put the progress call
                        # here so that time estimates (if any) can be updated
                        self.ui.progress(