comparison hgext/narrow/narrowcommands.py @ 42415:c767e655ffda

narrow: use narrow_widen wireproto command to widen in case of ellipses

Few releases ago, we introduce narrow_widen wireproto command to be used to widen
narrow repositories. Before this patch, that was used in non-ellipses cases
only. In ellipses cases, we still do exchange.pull() which can pull more data
than required.

After this patch, the client will first check whether server supports doing
ellipses widening using wireproto command or not by checking server's wireproto
capability. If the server is upto date and support latest ellipses capability,
we call the wireproto command. Otherwise we fallback to exchange.pull() like
before.

The compat code make sure that things works even if one of the client or server
is old. The initial version of this patch does not had this compat code. It's
added to help Google release things smoothly internally. I plan to drop the
compat code before the upcoming major release.

Due to change to wireproto command, the code looks a bit dirty, next patches
will clean that up.

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

42412:127937874395

        kwargs['includepats'] = include
    if exclude:
        kwargs['excludepats'] = exclude
    # calculate known nodes only in ellipses cases because in non-ellipses cases
    # we have all the nodes
    if wireprototypes.ELLIPSESCAP in pullop.remote.capabilities():
        kwargs['known'] = [node.hex(ctx.node()) for ctx in
                           repo.set('::%ln', pullop.common)
                           if ctx.node() != node.nullid]
        if not kwargs['known']:
            # Mercurial serializes an empty list as '' and deserializes it as

    # exchanging ellipses nodes. In future we should add ellipses as a client
    # side requirement (maybe) to distinguish a client is shallow or not and
    # then send that information to server whether we want ellipses or not.
    # Theoretically a non-ellipses repo should be able to use narrow
    # functionality from an ellipses enabled server
    ellipsesremote = wireprototypes.ELLIPSESCAP in remote.capabilities()

    def pullbundle2extraprepare_widen(orig, pullop, kwargs):
        orig(pullop, kwargs)
        # The old{in,ex}cludepats have already been set by orig()
        kwargs['includepats'] = newincludes

            ds = repo.dirstate
            p1, p2 = ds.p1(), ds.p2()
            with ds.parentchange():
                ds.setparents(node.nullid, node.nullid)
            with wrappedextraprepare:
                with repo.ui.configoverride(overrides, 'widen'):
                    exchange.pull(repo, remote, heads=common)
            with ds.parentchange():
                ds.setparents(p1, p2)
        else:
            with remote.commandexecutor() as e:
                bundle = e.callcommand('narrow_widen', {

42415:c767e655ffda

        kwargs['includepats'] = include
    if exclude:
        kwargs['excludepats'] = exclude
    # calculate known nodes only in ellipses cases because in non-ellipses cases
    # we have all the nodes
    if wireprototypes.ELLIPSESCAP1 in pullop.remote.capabilities():
        kwargs['known'] = [node.hex(ctx.node()) for ctx in
                           repo.set('::%ln', pullop.common)
                           if ctx.node() != node.nullid]
        if not kwargs['known']:
            # Mercurial serializes an empty list as '' and deserializes it as

    # exchanging ellipses nodes. In future we should add ellipses as a client
    # side requirement (maybe) to distinguish a client is shallow or not and
    # then send that information to server whether we want ellipses or not.
    # Theoretically a non-ellipses repo should be able to use narrow
    # functionality from an ellipses enabled server
    remotecap = remote.capabilities()
    ellipsesremote = any(cap in remotecap
                         for cap in wireprototypes.SUPPORTED_ELLIPSESCAP)

    # check whether we are talking to a server which supports old version of
    # ellipses capabilities
    isoldellipses = (ellipsesremote and wireprototypes.ELLIPSESCAP1 in
                     remotecap and wireprototypes.ELLIPSESCAP not in remotecap)

    def pullbundle2extraprepare_widen(orig, pullop, kwargs):
        orig(pullop, kwargs)
        # The old{in,ex}cludepats have already been set by orig()
        kwargs['includepats'] = newincludes

            ds = repo.dirstate
            p1, p2 = ds.p1(), ds.p2()
            with ds.parentchange():
                ds.setparents(node.nullid, node.nullid)
            with wrappedextraprepare:
                if isoldellipses:
                    exchange.pull(repo, remote, heads=common)
                else:
                    known = [node.hex(ctx.node()) for ctx in
                                       repo.set('::%ln', common)
                                       if ctx.node() != node.nullid]

                    with remote.commandexecutor() as e:
                        bundle = e.callcommand('narrow_widen', {
                            'oldincludes': oldincludes,
                            'oldexcludes': oldexcludes,
                            'newincludes': newincludes,
                            'newexcludes': newexcludes,
                            'cgversion': '03',
                            'commonheads': common,
                            'known': known,
                            'ellipses': True,
                        }).result()
                    trmanager = exchange.transactionmanager(repo, 'widen',
                                                            remote.url())
                    with trmanager:
                        op = bundle2.bundleoperation(repo,
                                trmanager.transaction, source='widen')
                        bundle2.processbundle(repo, bundle, op=op)

            with ds.parentchange():
                ds.setparents(p1, p2)
        else:
            with remote.commandexecutor() as e:
                bundle = e.callcommand('narrow_widen', {