mercurial/changegroup.py

38906:0548f696795b

    deltachunks = attr.ib()

class cgpacker(object):
    def __init__(self, repo, filematcher, version, allowreorder,
                 useprevdelta, builddeltaheader, manifestsend,
                 sendtreemanifests, bundlecaps=None, shallow=False):
        """Given a source repo, construct a bundler.

        filematcher is a matcher that matches on files to include in the
        changegroup. Used to facilitate sparse changegroups.

        # Set of capabilities we can use to build the bundle.
        if bundlecaps is None:
            bundlecaps = set()
        self._bundlecaps = bundlecaps
        self._isshallow = shallow

        # experimental config: bundle.reorder
        reorder = repo.ui.config('bundle', 'reorder')
        if reorder == 'auto':
            self._reorder = allowreorder

                # 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._full_nodes
                    or cl.rev(x) in self._precomputed_ellipsis):
                    n = c[0]
                    # Record the first changeset introducing this manifest
                    # version.
                    mfs.setdefault(n, x)
                    # Set this narrow-specific dict so we have the lowest

        if linknode in self._full_nodes:
            return self._revisiondeltanormal(store, rev, prev, linknode)

        # At this point, a node can either be one we should skip or an
        # ellipsis. If it's not an ellipsis, bail immediately.
        if linkrev not in self._precomputed_ellipsis:
            return

        linkparents = self._precomputed_ellipsis[linkrev]
        def local(clrev):
            """Turn a changelog revnum into a local revnum.

            The ellipsis dag is stored as revnums on the changelog,
            but when we're producing ellipsis entries for

                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]
                                    if pp != nullrev])
                else:
                    # In this case, we've got an ellipsis with parents
                    # outside the current bundle (likely an
                    # incremental pull). We "know" that we can use the

            linknode=linknode,
            flags=flags,
            deltachunks=(diffheader, data),
        )

def _makecg1packer(repo, filematcher, bundlecaps, shallow=False):
    builddeltaheader = lambda d: _CHANGEGROUPV1_DELTA_HEADER.pack(
        d.node, d.p1node, d.p2node, d.linknode)

    return cgpacker(repo, filematcher, b'01',
                    useprevdelta=True,
                    allowreorder=None,
                    builddeltaheader=builddeltaheader,
                    manifestsend=b'',
                    sendtreemanifests=False,
                    bundlecaps=bundlecaps,
                    shallow=shallow)

def _makecg2packer(repo, filematcher, bundlecaps, shallow=False):
    builddeltaheader = lambda d: _CHANGEGROUPV2_DELTA_HEADER.pack(
        d.node, d.p1node, d.p2node, d.basenode, d.linknode)

    # Since generaldelta is directly supported by cg2, reordering
    # generally doesn't help, so we disable it by default (treating

                    allowreorder=False,
                    builddeltaheader=builddeltaheader,
                    manifestsend=b'',
                    sendtreemanifests=False,
                    bundlecaps=bundlecaps,
                    shallow=shallow)

def _makecg3packer(repo, filematcher, bundlecaps, shallow=False):
    builddeltaheader = lambda d: _CHANGEGROUPV3_DELTA_HEADER.pack(
        d.node, d.p1node, d.p2node, d.basenode, d.linknode, d.flags)

    return cgpacker(repo, filematcher, b'03',
                    useprevdelta=False,
                    allowreorder=False,
                    builddeltaheader=builddeltaheader,
                    manifestsend=closechunk(),
                    sendtreemanifests=True,
                    bundlecaps=bundlecaps,
                    shallow=shallow)

_packermap = {'01': (_makecg1packer, cg1unpacker),
             # cg2 adds support for exchanging generaldelta
             '02': (_makecg2packer, cg2unpacker),
             # cg3 adds support for exchanging revlog flags and treemanifests

        versions.discard('01')
    assert versions
    return min(versions)

def getbundler(version, repo, bundlecaps=None, filematcher=None,
               shallow=False):
    assert version in supportedoutgoingversions(repo)

    if filematcher is None:
        filematcher = matchmod.alwaysmatcher(repo.root, '')

    # filter those out.
    filematcher = matchmod.intersectmatchers(repo.narrowmatch(),
                                             filematcher)

    fn = _packermap[version][0]
    return fn(repo, filematcher, bundlecaps, shallow=shallow)

def getunbundler(version, fh, alg, extras=None):
    return _packermap[version][1](fh, alg, extras=extras)

def _changegroupinfo(repo, nodes, source):

    # relevant_nodes into that area. Then if linknode isn't in the
    # set, we know we have an ellipsis node and we should defer
    # sending that node's data. We override close() to detect
    # pending ellipsis nodes and flush them.
    packer = getbundler(version, repo, filematcher=match,
                        shallow=depth is not None)
    # Give the packer the list of nodes which should not be
    # ellipsis nodes. We store this rather than the set of nodes
    # 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)

38907:ad4c4cc9a5ac

    deltachunks = attr.ib()

class cgpacker(object):
    def __init__(self, repo, filematcher, version, allowreorder,
                 useprevdelta, builddeltaheader, manifestsend,
                 sendtreemanifests, bundlecaps=None, shallow=False,
                 ellipsisroots=None):
        """Given a source repo, construct a bundler.

        filematcher is a matcher that matches on files to include in the
        changegroup. Used to facilitate sparse changegroups.

        # Set of capabilities we can use to build the bundle.
        if bundlecaps is None:
            bundlecaps = set()
        self._bundlecaps = bundlecaps
        self._isshallow = shallow

        # Maps ellipsis revs to their roots at the changelog level.
        self._precomputedellipsis = ellipsisroots

        # experimental config: bundle.reorder
        reorder = repo.ui.config('bundle', 'reorder')
        if reorder == 'auto':
            self._reorder = allowreorder

                # 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._full_nodes
                    or cl.rev(x) in self._precomputedellipsis):
                    n = c[0]
                    # Record the first changeset introducing this manifest
                    # version.
                    mfs.setdefault(n, x)
                    # Set this narrow-specific dict so we have the lowest

        if linknode in self._full_nodes:
            return self._revisiondeltanormal(store, rev, prev, linknode)

        # At this point, a node can either be one we should skip or an
        # ellipsis. If it's not an ellipsis, bail immediately.
        if linkrev not in self._precomputedellipsis:
            return

        linkparents = self._precomputedellipsis[linkrev]
        def local(clrev):
            """Turn a changelog revnum into a local revnum.

            The ellipsis dag is stored as revnums on the changelog,
            but when we're producing ellipsis entries for

                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._precomputedellipsis:
                    walk.extend([pp for pp in self._precomputedellipsis[p]
                                    if pp != nullrev])
                else:
                    # In this case, we've got an ellipsis with parents
                    # outside the current bundle (likely an
                    # incremental pull). We "know" that we can use the

            linknode=linknode,
            flags=flags,
            deltachunks=(diffheader, data),
        )

def _makecg1packer(repo, filematcher, bundlecaps, shallow=False,
                   ellipsisroots=None):
    builddeltaheader = lambda d: _CHANGEGROUPV1_DELTA_HEADER.pack(
        d.node, d.p1node, d.p2node, d.linknode)

    return cgpacker(repo, filematcher, b'01',
                    useprevdelta=True,
                    allowreorder=None,
                    builddeltaheader=builddeltaheader,
                    manifestsend=b'',
                    sendtreemanifests=False,
                    bundlecaps=bundlecaps,
                    shallow=shallow,
                    ellipsisroots=ellipsisroots)

def _makecg2packer(repo, filematcher, bundlecaps, shallow=False,
                   ellipsisroots=None):
    builddeltaheader = lambda d: _CHANGEGROUPV2_DELTA_HEADER.pack(
        d.node, d.p1node, d.p2node, d.basenode, d.linknode)

    # Since generaldelta is directly supported by cg2, reordering
    # generally doesn't help, so we disable it by default (treating

                    allowreorder=False,
                    builddeltaheader=builddeltaheader,
                    manifestsend=b'',
                    sendtreemanifests=False,
                    bundlecaps=bundlecaps,
                    shallow=shallow,
                    ellipsisroots=ellipsisroots)

def _makecg3packer(repo, filematcher, bundlecaps, shallow=False,
                   ellipsisroots=None):
    builddeltaheader = lambda d: _CHANGEGROUPV3_DELTA_HEADER.pack(
        d.node, d.p1node, d.p2node, d.basenode, d.linknode, d.flags)

    return cgpacker(repo, filematcher, b'03',
                    useprevdelta=False,
                    allowreorder=False,
                    builddeltaheader=builddeltaheader,
                    manifestsend=closechunk(),
                    sendtreemanifests=True,
                    bundlecaps=bundlecaps,
                    shallow=shallow,
                    ellipsisroots=ellipsisroots)

_packermap = {'01': (_makecg1packer, cg1unpacker),
             # cg2 adds support for exchanging generaldelta
             '02': (_makecg2packer, cg2unpacker),
             # cg3 adds support for exchanging revlog flags and treemanifests

        versions.discard('01')
    assert versions
    return min(versions)

def getbundler(version, repo, bundlecaps=None, filematcher=None,
               shallow=False, ellipsisroots=None):
    assert version in supportedoutgoingversions(repo)

    if filematcher is None:
        filematcher = matchmod.alwaysmatcher(repo.root, '')

    # filter those out.
    filematcher = matchmod.intersectmatchers(repo.narrowmatch(),
                                             filematcher)

    fn = _packermap[version][0]
    return fn(repo, filematcher, bundlecaps, shallow=shallow,
              ellipsisroots=ellipsisroots)

def getunbundler(version, fh, alg, extras=None):
    return _packermap[version][1](fh, alg, extras=extras)

def _changegroupinfo(repo, nodes, source):

    # relevant_nodes into that area. Then if linknode isn't in the
    # set, we know we have an ellipsis node and we should defer
    # sending that node's data. We override close() to detect
    # pending ellipsis nodes and flush them.
    packer = getbundler(version, repo, filematcher=match,
                        shallow=depth is not None,
                        ellipsisroots=ellipsisroots)
    # Give the packer the list of nodes which should not be
    # ellipsis nodes. We store this rather than the set of nodes
    # that should be an ellipsis because for very large histories
    # we expect this to be significantly smaller.
    packer._full_nodes = relevant_nodes

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