( )⚙ D665 changegroup: replace changegroupsubset with makechangegroup

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D665

changegroup: replace changegroupsubset with makechangegroup
ClosedPublic

Authored by durham on Sep 10 2017, 10:06 PM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHGf7d41b85bbf6: changegroup: replace changegroupsubset with makechangegroup
Summary

As part of getting rid of all the permutations of changegroup creation, let's
remove changegroupsubset and call makechangegroup instead. This moves the
responsibility of creating the outgoing set to the caller, but that seems like a
relatively reasonable unit of functionality for the caller to have to care about
(i.e. what commits should be bundled).

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

durham created this revision.Sep 10 2017, 10:06 PM
indygreg accepted this revision.Sep 11 2017, 6:20 PM
indygreg added a subscriber: indygreg.

I agree that passing in the outgoing data structure makes sense. Discovery should be done before changegroup APIs are called.

This revision is now accepted and ready to land.Sep 11 2017, 6:20 PM
Closed by commit rHGf7d41b85bbf6: changegroup: replace changegroupsubset with makechangegroup (authored by durham). · Explain WhySep 11 2017, 6:27 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext/shelve.py (8 lines)
Mmercurial/changegroup.py (20 lines)
Mmercurial/localrepo.py (5 lines)
Mmercurial/wireproto.py (5 lines)

Diff 1692

hgext/shelve.py

from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
bookmarks, bookmarks,
bundle2, bundle2,
bundlerepo, bundlerepo,
changegroup, changegroup,
cmdutil, cmdutil,
discovery,
error, error,
exchange, exchange,
hg, hg,
lock as lockmod, lock as lockmod,
mdiff, mdiff,
merge, merge,
node as nodemod, node as nodemod,
patch, patch,
cgversion = changegroup.safeversion(self.repo) cgversion = changegroup.safeversion(self.repo)
if cgversion == '01': if cgversion == '01':
btype = 'HG10BZ' btype = 'HG10BZ'
compression = None compression = None
else: else:
btype = 'HG20' btype = 'HG20'
compression = 'BZ' compression = 'BZ'
cg = changegroup.changegroupsubset(self.repo, bases, [node], 'shelve', outgoing = discovery.outgoing(self.repo, missingroots=bases,
version=cgversion) missingheads=[node])
cg = changegroup.makechangegroup(self.repo, outgoing, cgversion,
'shelve')
bundle2.writebundle(self.ui, cg, self.fname, btype, self.vfs, bundle2.writebundle(self.ui, cg, self.fname, btype, self.vfs,
compression=compression) compression=compression)
def writeobsshelveinfo(self, info): def writeobsshelveinfo(self, info):
scmutil.simplekeyvaluefile(self.vfs, self.fname).write(info) scmutil.simplekeyvaluefile(self.vfs, self.fname).write(info)
def readobsshelveinfo(self): def readobsshelveinfo(self):
return scmutil.simplekeyvaluefile(self.vfs, self.fname).read() return scmutil.simplekeyvaluefile(self.vfs, self.fname).read()

mercurial/changegroup.py

heads.sort() heads.sort()
fastpathlinkrev = fastpath or ( fastpathlinkrev = fastpath or (
repo.filtername is None and heads == sorted(repo.heads())) repo.filtername is None and heads == sorted(repo.heads()))
repo.hook('preoutgoing', throw=True, source=source) repo.hook('preoutgoing', throw=True, source=source)
_changegroupinfo(repo, csets, source) _changegroupinfo(repo, csets, source)
return bundler.generate(commonrevs, csets, fastpathlinkrev, source) return bundler.generate(commonrevs, csets, fastpathlinkrev, source)
def changegroupsubset(repo, roots, heads, source, version='01'):
"""Compute a changegroup consisting of all the nodes that are
descendants of any of the roots and ancestors of any of the heads.
Return a chunkbuffer object whose read() method will return
successive changegroup chunks.
It is fairly complex as determining which filenodes and which
manifest nodes need to be included for the changeset to be complete
is non-trivial.
Another wrinkle is doing the reverse, figuring out which changeset in
the changegroup a particular filenode or manifestnode belongs to.
"""
outgoing = discovery.outgoing(repo, missingroots=roots, missingheads=heads)
return makechangegroup(repo, outgoing, version, source)
def getlocalchangegroupraw(repo, source, outgoing, bundlecaps=None, def getlocalchangegroupraw(repo, source, outgoing, bundlecaps=None,
version='01'): version='01'):
"""Like getbundle, but taking a discovery.outgoing as an argument. """Like getbundle, but taking a discovery.outgoing as an argument.
This is only implemented for local repos and reuses potentially This is only implemented for local repos and reuses potentially
precomputed sets in outgoing. Returns a raw changegroup generator.""" precomputed sets in outgoing. Returns a raw changegroup generator."""
if not outgoing.missing: if not outgoing.missing:
return None return None
def getlocalchangegroup(repo, *args, **kwargs): def getlocalchangegroup(repo, *args, **kwargs):
repo.ui.deprecwarn('getlocalchangegroup is deprecated, use getchangegroup', repo.ui.deprecwarn('getlocalchangegroup is deprecated, use getchangegroup',
'4.3') '4.3')
return getchangegroup(repo, *args, **kwargs) return getchangegroup(repo, *args, **kwargs)
def changegroup(repo, basenodes, source): def changegroup(repo, basenodes, source):
# to avoid a race we use changegroupsubset() (issue1320) # to avoid a race we use changegroupsubset() (issue1320)
return changegroupsubset(repo, basenodes, repo.heads(), source) outgoing = discovery.outgoing(repo, missingroots=basenodes,
missingheads=repo.heads())
return makechangegroup(repo, outgoing, '01', source)
def _addchangegroupfiles(repo, source, revmap, trp, expectedfiles, needfiles): def _addchangegroupfiles(repo, source, revmap, trp, expectedfiles, needfiles):
revisions = 0 revisions = 0
files = 0 files = 0
for chunkdata in iter(source.filelogheader, {}): for chunkdata in iter(source.filelogheader, {}):
files += 1 files += 1
f = chunkdata["filename"] f = chunkdata["filename"]
repo.ui.debug("adding %s revisions\n" % f) repo.ui.debug("adding %s revisions\n" % f)

mercurial/localrepo.py

branchmap, branchmap,
bundle2, bundle2,
changegroup, changegroup,
changelog, changelog,
color, color,
context, context,
dirstate, dirstate,
dirstateguard, dirstateguard,
discovery,
encoding, encoding,
error, error,
exchange, exchange,
extensions, extensions,
filelog, filelog,
hook, hook,
lock as lockmod, lock as lockmod,
manifest, manifest,
def branches(self, nodes): def branches(self, nodes):
return self._repo.branches(nodes) return self._repo.branches(nodes)
def changegroup(self, basenodes, source): def changegroup(self, basenodes, source):
return changegroup.changegroup(self._repo, basenodes, source) return changegroup.changegroup(self._repo, basenodes, source)
def changegroupsubset(self, bases, heads, source): def changegroupsubset(self, bases, heads, source):
return changegroup.changegroupsubset(self._repo, bases, heads, source) outgoing = discovery.outgoing(self._repo, missingroots=bases,
missingheads=heads)
return changegroup.makechangegroup(self._repo, outgoing, '01', source)
# End of baselegacywirecommands interface. # End of baselegacywirecommands interface.
# Increment the sub-version when the revlog v2 format changes to lock out old # Increment the sub-version when the revlog v2 format changes to lock out old
# clients. # clients.
REVLOGV2_REQUIREMENT = 'exp-revlogv2.0' REVLOGV2_REQUIREMENT = 'exp-revlogv2.0'
class localrepository(object): class localrepository(object):

mercurial/wireproto.py

bin, bin,
hex, hex,
nullid, nullid,
) )
from . import ( from . import (
bundle2, bundle2,
changegroup as changegroupmod, changegroup as changegroupmod,
discovery,
encoding, encoding,
error, error,
exchange, exchange,
peer, peer,
pushkey as pushkeymod, pushkey as pushkeymod,
pycompat, pycompat,
repository, repository,
streamclone, streamclone,
nodes = decodelist(roots) nodes = decodelist(roots)
cg = changegroupmod.changegroup(repo, nodes, 'serve') cg = changegroupmod.changegroup(repo, nodes, 'serve')
return streamres(reader=cg, v1compressible=True) return streamres(reader=cg, v1compressible=True)
@wireprotocommand('changegroupsubset', 'bases heads') @wireprotocommand('changegroupsubset', 'bases heads')
def changegroupsubset(repo, proto, bases, heads): def changegroupsubset(repo, proto, bases, heads):
bases = decodelist(bases) bases = decodelist(bases)
heads = decodelist(heads) heads = decodelist(heads)
cg = changegroupmod.changegroupsubset(repo, bases, heads, 'serve') outgoing = discovery.outgoing(repo, missingroots=bases,
missingheads=heads)
cg = changegroupmod.makechangegroup(repo, outgoing, '01', 'serve')
return streamres(reader=cg, v1compressible=True) return streamres(reader=cg, v1compressible=True)
@wireprotocommand('debugwireargs', 'one two *') @wireprotocommand('debugwireargs', 'one two *')
def debugwireargs(repo, proto, one, two, others): def debugwireargs(repo, proto, one, two, others):
# only accept optional args from the known set # only accept optional args from the known set
opts = options('debugwireargs', ['three', 'four'], others) opts = options('debugwireargs', ['three', 'four'], others)
return repo.debugwireargs(one, two, **opts) return repo.debugwireargs(one, two, **opts)