comparison mercurial/changegroup.py @ 38904:cdb9bc216771

changegroup: declare shallow flag in constructor

Thus begins the process of better formalizing ellipses and shallow
changegroup generation mode so it is tracked by cgpacker at
construction time instead of bolted on after the fact by a
wrapper function.

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

38903:68e490ed640e

    deltachunks = attr.ib()

class cgpacker(object):
    def __init__(self, repo, filematcher, version, allowreorder,
                 useprevdelta, builddeltaheader, manifestsend,
                 sendtreemanifests, bundlecaps=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.

        bundlecaps is optional and can be used to specify the set of
        capabilities which can be used to build the bundle. While bundlecaps is
        unused in core Mercurial, extensions rely on this feature to communicate
        capabilities to customize the changegroup packer.
        """
        assert filematcher
        self._filematcher = filematcher

        self.version = version

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

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

                    # 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._is_shallow:
                    changedfiles.update(mfl[c[0]].read().keys())
                else:
                    changedfiles.update(c[3])
            else:

                fastpathlinkrev, mfs, fnodes, source):
            yield chunk

        if ellipsesmode:
            mfdicts = None
            if self._is_shallow:
                mfdicts = [(self._repo.manifestlog[n].read(), lr)
                           for (n, lr) in mfs.iteritems()]

        mfs.clear()
        clrevs = set(cl.rev(x) for x in clnodes)

    # The 'source' parameter is useful for extensions
    def generatefiles(self, changedfiles, linknodes, commonrevs, source):
        changedfiles = list(filter(self._filematcher, changedfiles))

        if getattr(self, '_is_shallow', False):
            # See comment in generate() for why this sadness is a thing.
            mfdicts = self._mfdicts
            del self._mfdicts
            # In a shallow clone, the linknodes callback needs to also include
            # those file nodes that are in the manifests we sent but weren't

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

def _makecg1packer(repo, filematcher, bundlecaps):
    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)

def _makecg2packer(repo, filematcher, bundlecaps):
    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

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

def _makecg3packer(repo, filematcher, bundlecaps):
    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)

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

    if 'generaldelta' in repo.requirements:
        versions.discard('01')
    assert versions
    return min(versions)

def getbundler(version, repo, bundlecaps=None, filematcher=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)

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

def _changegroupinfo(repo, nodes, source):

    # We wrap cg1packer.revchunk, using a side channel to pass
    # 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)
    # 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

    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 = {}
    packer._changelog_done = False
    # If true, informs the packer that it is serving shallow content and might
    # need to pack file contents not introduced by the changes being packed.
    packer._is_shallow = depth is not None

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

38904:cdb9bc216771

    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.

        bundlecaps is optional and can be used to specify the set of
        capabilities which can be used to build the bundle. While bundlecaps is
        unused in core Mercurial, extensions rely on this feature to communicate
        capabilities to customize the changegroup packer.

        shallow indicates whether shallow data might be sent. The packer may
        need to pack file contents not introduced by the changes being packed.
        """
        assert filematcher
        self._filematcher = filematcher

        self.version = version

        # 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

                    # 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:
                    changedfiles.update(c[3])
            else:

                fastpathlinkrev, mfs, fnodes, source):
            yield chunk

        if ellipsesmode:
            mfdicts = None
            if self._isshallow:
                mfdicts = [(self._repo.manifestlog[n].read(), lr)
                           for (n, lr) in mfs.iteritems()]

        mfs.clear()
        clrevs = set(cl.rev(x) for x in clnodes)

    # The 'source' parameter is useful for extensions
    def generatefiles(self, changedfiles, linknodes, commonrevs, source):
        changedfiles = list(filter(self._filematcher, changedfiles))

        if self._isshallow:
            # See comment in generate() for why this sadness is a thing.
            mfdicts = self._mfdicts
            del self._mfdicts
            # In a shallow clone, the linknodes callback needs to also include
            # those file nodes that are in the manifests we sent but weren't

            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

                    useprevdelta=False,
                    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

    if 'generaldelta' in repo.requirements:
        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):

    # We wrap cg1packer.revchunk, using a side channel to pass
    # 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

    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 = {}
    packer._changelog_done = False

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