This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5290

branchmap: rename partial -> bcache
ClosedPublic

Authored by mjpieters on Nov 20 2018, 8:45 AM.

Details

Reviewers
martinvonz
Group Reviewers
hg-reviewers
Commits
rHG3461814417f3: branchmap: rename partial -> bcache
Summary

The name better reflects that we have a branchcache object here, even if at
*some point* it is still being constructed.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

mjpieters created this revision.Nov 20 2018, 8:45 AM
mjpieters added a comment.Nov 22 2018, 6:38 AM

The goal of this refactor is to bring clarity to the branchmap cache behaviour, and to make it easier to add performance improvements (in an upcoming additional series of patches).

yuja added a subscriber: yuja.Nov 23 2018, 10:24 PM

Can you split this to a couple of patches?

The idea sounds good, but it isn't easy to review formatting changes,
code moves, and interface improvements as a single patch.

mjpieters edited the summary of this revision. (Show Details)Jan 21 2019, 1:07 PM
mjpieters retitled this revision from branchmap: refactor for better encapsulation to branchmap: rename partial -> bcache.
mjpieters added a child revision: D5635: branchmap: make branchcache responsible for reading.
mjpieters updated this revision to Diff 13329.
mjpieters added a comment.Jan 21 2019, 1:13 PM

@yuja: you wanted separate commits, you got separate commits. :-)

(and apologies for taking so long)

martinvonz accepted this revision.Jan 25 2019, 3:20 PM
This revision is now accepted and ready to land.Jan 25 2019, 3:20 PM
Closed by commit rHG3461814417f3: branchmap: rename partial -> bcache (authored by mjpieters). · Explain WhyJan 26 2019, 2:17 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 12573

contrib/perf.py

else: else:
view = repo.filtered(filtername) view = repo.filtered(filtername)
def d(): def d():
if clear_revbranch: if clear_revbranch:
repo.revbranchcache()._clear() repo.revbranchcache()._clear()
if full: if full:
view._branchcaches.clear() view._branchcaches.clear()
else: else:
view._branchcaches.pop(filtername, None) view._branchcaches._per_filter.pop(filtername, None)
view.branchmap() view.branchmap()
return d return d
# add filter in smaller subset to bigger subset # add filter in smaller subset to bigger subset
possiblefilters = set(repoview.filtertable) possiblefilters = set(repoview.filtertable)
if filternames: if filternames:
possiblefilters &= set(filternames) possiblefilters &= set(filternames)
subsettable = getbranchmapsubsettable() subsettable = getbranchmapsubsettable()
allfilters = [] allfilters = []
# warm the cache # warm the cache
if not full: if not full:
for name in allfilters: for name in allfilters:
repo.filtered(name).branchmap() repo.filtered(name).branchmap()
if not filternames or b'unfiltered' in filternames: if not filternames or b'unfiltered' in filternames:
# add unfiltered # add unfiltered
allfilters.append(None) allfilters.append(None)
branchcacheread = safeattrsetter(branchmap, b'read') branchcacheread = safeattrsetter(branchmap.branchcache, b'fromfile')
branchcachewrite = safeattrsetter(branchmap.branchcache, b'write') branchcachewrite = safeattrsetter(branchmap.branchcache, b'write')
branchcacheread.set(lambda repo: None) branchcacheread.set(classmethod(lambda *args: None))
branchcachewrite.set(lambda bc, repo: None) branchcachewrite.set(lambda *args: None)
try: try:
for name in allfilters: for name in allfilters:
printname = name printname = name
if name is None: if name is None:
printname = b'unfiltered' printname = b'unfiltered'
timer(getbranchmap(name), title=str(printname)) timer(getbranchmap(name), title=str(printname))
finally: finally:
branchcacheread.restore() branchcacheread.restore()

mercurial/branchmap.py

from .utils import ( from .utils import (
stringutil, stringutil,
) )
calcsize = struct.calcsize calcsize = struct.calcsize
pack_into = struct.pack_into pack_into = struct.pack_into
unpack_from = struct.unpack_from unpack_from = struct.unpack_from
def _filename(repo):
"""name of a branchcache file for a given repo or repoview"""
filename = "branch2"
if repo.filtername:
filename = '%s-%s' % (filename, repo.filtername)
return filename
def read(repo):
f = None
try:
f = repo.cachevfs(_filename(repo))
lineiter = iter(f)
cachekey = next(lineiter).rstrip('\n').split(" ", 2)
last, lrev = cachekey[:2]
last, lrev = bin(last), int(lrev)
filteredhash = None
if len(cachekey) > 2:
filteredhash = bin(cachekey[2])
partial = branchcache(tipnode=last, tiprev=lrev,
filteredhash=filteredhash)
if not partial.validfor(repo):
# invalidate the cache
raise ValueError(r'tip differs')
cl = repo.changelog
for l in lineiter:
l = l.rstrip('\n')
if not l:
continue
node, state, label = l.split(" ", 2)
if state not in 'oc':
raise ValueError(r'invalid branch state')
label = encoding.tolocal(label.strip())
node = bin(node)
if not cl.hasnode(node):
raise ValueError(
r'node %s does not exist' % pycompat.sysstr(hex(node)))
partial.setdefault(label, []).append(node)
if state == 'c':
partial._closednodes.add(node)
except (IOError, OSError):
return None
except Exception as inst:
if repo.ui.debugflag:
msg = 'invalid branchheads cache'
if repo.filtername is not None:
msg += ' (%s)' % repo.filtername
msg += ': %s\n'
repo.ui.debug(msg % pycompat.bytestr(inst))
partial = None
finally:
if f:
f.close()
return partial
### Nearest subset relation # ## Nearest subset relation
# Nearest subset of filter X is a filter Y so that: # Nearest subset of filter X is a filter Y so that:
# * Y is included in X, # * Y is included in X,
# * X - Y is as small as possible. # * X - Y is as small as possible.
# This create and ordering used for branchmap purpose. # This create and ordering used for branchmap purpose.
# the ordering may be partial # the ordering may be partial
subsettable = {None: 'visible', subsettable = {None: 'visible',
'visible-hidden': 'visible', 'visible-hidden': 'visible',
'visible': 'served', 'visible': 'served',
'served': 'immutable', 'served': 'immutable',
'immutable': 'base'} 'immutable': 'base'}
def updatecache(repo):
class BranchMapCache(object):
"""Cache mapping"""
def __init__(self):
self._per_filter = {}
def __getitem__(self, repo):
self.updatecache(repo)
return self._per_filter[repo.filtername]
def updatecache(self, repo):
"""Update the cache for the given filtered view on a repository"""
# This can trigger updates for the caches for subsets of the filtered
# view, e.g. when there is no cache for this filtered view or the cache
# is stale.
cl = repo.changelog cl = repo.changelog
filtername = repo.filtername filtername = repo.filtername
partial = repo._branchcaches.get(filtername) frbm = self._per_filter.get(filtername)
if frbm is None or not frbm.validfor(repo):
# cache object missing or cache object stale? Read from disk
frbm = branchcache.fromfile(repo)
revs = [] revs = []
if partial is None or not partial.validfor(repo): if frbm is None:
partial = read(repo) # no (fresh) cache available anymore, perhaps we can re-use
if partial is None: # the cache for a subset, then extend that to add info on missing
# revisions.
subsetname = subsettable.get(filtername) subsetname = subsettable.get(filtername)
if subsetname is None: if subsetname is not None:
partial = branchcache()
else:
subset = repo.filtered(subsetname) subset = repo.filtered(subsetname)
partial = subset.branchmap().copy() frbm = self[subset].copy()
extrarevs = subset.changelog.filteredrevs - cl.filteredrevs extrarevs = subset.changelog.filteredrevs - cl.filteredrevs
revs.extend(r for r in extrarevs if r <= partial.tiprev) revs.extend(r for r in extrarevs if r <= frbm.tiprev)
revs.extend(cl.revs(start=partial.tiprev + 1)) else:
# nothing to fall back on, start empty.
frbm = branchcache()
revs.extend(cl.revs(start=frbm.tiprev + 1))
if revs: if revs:
partial.update(repo, revs) frbm.update(repo, revs)
partial.write(repo)
assert partial.validfor(repo), filtername assert frbm.validfor(repo), filtername
repo._branchcaches[repo.filtername] = partial self._per_filter[repo.filtername] = frbm
def replacecache(repo, bm): def replace(self, repo, remotebranchmap):
"""Replace the branchmap cache for a repo with a branch mapping. """Replace the branchmap cache for a repo with a branch mapping.
This is likely only called during clone with a branch map from a remote. This is likely only called during clone with a branch map from a
remote.
""" """
cl = repo.changelog cl = repo.changelog
clrev = cl.rev clrev = cl.rev
clbranchinfo = cl.branchinfo clbranchinfo = cl.branchinfo
rbheads = [] rbheads = []
closed = [] closed = []
for bheads in bm.itervalues(): for bheads in remotebranchmap.itervalues():
rbheads.extend(bheads) rbheads += bheads
for h in bheads: for h in bheads:
r = clrev(h) r = clrev(h)
b, c = clbranchinfo(r) b, c = clbranchinfo(r)
if c: if c:
closed.append(h) closed.append(h)
if rbheads: if rbheads:
rtiprev = max((int(clrev(node)) rtiprev = max((int(clrev(node)) for node in rbheads))
for node in rbheads)) cache = branchcache(
cache = branchcache(bm, remotebranchmap, repo[rtiprev].node(), rtiprev,
repo[rtiprev].node(),
rtiprev,
closednodes=closed) closednodes=closed)
# Try to stick it as low as possible # Try to stick it as low as possible
# filter above served are unlikely to be fetch from a clone # filter above served are unlikely to be fetch from a clone
for candidate in ('base', 'immutable', 'served'): for candidate in ('base', 'immutable', 'served'):
rview = repo.filtered(candidate) rview = repo.filtered(candidate)
if cache.validfor(rview): if cache.validfor(rview):
repo._branchcaches[candidate] = cache self._per_filter[candidate] = cache
cache.write(rview) cache.write(rview)
break return
def clear(self):
self._per_filter.clear()
class branchcache(dict): class branchcache(dict):
"""A dict like object that hold branches heads cache. """A dict like object that hold branches heads cache.
This cache is used to avoid costly computations to determine all the This cache is used to avoid costly computations to determine all the
branch heads of a repo. branch heads of a repo.
The cache is serialized on disk in the following format: The cache is serialized on disk in the following format:
<tip hex node> <tip rev number> [optional filtered repo hex hash] <tip hex node> <tip rev number> [optional filtered repo hex hash]
<branch head hex node> <open/closed state> <branch name> <branch head hex node> <open/closed state> <branch name>
<branch head hex node> <open/closed state> <branch name> <branch head hex node> <open/closed state> <branch name>
... ...
The first line is used to check if the cache is still valid. If the The first line is used to check if the cache is still valid. If the
branch cache is for a filtered repo view, an optional third hash is branch cache is for a filtered repo view, an optional third hash is
included that hashes the hashes of all filtered revisions. included that hashes the hashes of all filtered revisions.
The open/closed state is represented by a single letter 'o' or 'c'. The open/closed state is represented by a single letter 'o' or 'c'.
This field can be used to avoid changelog reads when determining if a This field can be used to avoid changelog reads when determining if a
branch head closes a branch or not. branch head closes a branch or not.
""" """
@classmethod
def fromfile(cls, repo):
f = None
try:
f = repo.cachevfs(cls._filename(repo))
lineiter = iter(f)
cachekey = next(lineiter).rstrip('\n').split(" ", 2)
last, lrev = cachekey[:2]
last, lrev = bin(last), int(lrev)
filteredhash = None
if len(cachekey) > 2:
filteredhash = bin(cachekey[2])
frbm = cls(tipnode=last, tiprev=lrev, filteredhash=filteredhash)
if not frbm.validfor(repo):
# invalidate the cache
raise ValueError(r'tip differs')
cl = repo.changelog
for line in lineiter:
line = line.rstrip('\n')
if not line:
continue
node, state, label = line.split(" ", 2)
if state not in 'oc':
raise ValueError(r'invalid branch state')
label = encoding.tolocal(label.strip())
node = bin(node)
if not cl.hasnode(node):
raise ValueError(
r'node %s does not exist' % pycompat.sysstr(hex(node)))
frbm.setdefault(label, []).append(node)
if state == 'c':
frbm._closednodes.add(node)
except (IOError, OSError):
return None
except Exception as inst:
if repo.ui.debugflag:
msg = 'invalid branchheads cache'
if repo.filtername is not None:
msg += ' (%s)' % repo.filtername
msg += ': %s\n'
repo.ui.debug(msg % pycompat.bytestr(inst))
frbm = None
finally:
if f:
f.close()
return frbm
@staticmethod
def _filename(repo):
"""name of a branchcache file for a given repo or repoview"""
filename = "branch2"
if repo.filtername:
filename = '%s-%s' % (filename, repo.filtername)
return filename
def __init__(self, entries=(), tipnode=nullid, tiprev=nullrev, def __init__(self, entries=(), tipnode=nullid, tiprev=nullrev,
filteredhash=None, closednodes=None): filteredhash=None, closednodes=None):
super(branchcache, self).__init__(entries) super(branchcache, self).__init__(entries)
self.tipnode = tipnode self.tipnode = tipnode
self.tiprev = tiprev self.tiprev = tiprev
self.filteredhash = filteredhash self.filteredhash = filteredhash
# closednodes is a set of nodes that close their branch. If the branch # closednodes is a set of nodes that close their branch. If the branch
# cache has been updated, it may contain nodes that are no longer # cache has been updated, it may contain nodes that are no longer
# heads. # heads.
if closednodes is None: if closednodes is None:
self._closednodes = set() self._closednodes = set()
else: else:
self._closednodes = closednodes self._closednodes = closednodes
def validfor(self, repo): def validfor(self, repo):
"""Is the cache content valid regarding a repo """Is the cache content valid regarding a repo
- False when cached tipnode is unknown or if we detect a strip. - False when cached tipnode is unknown or if we detect a strip.
- True when cache is up to date or a subset of current repo.""" - True when cache is up to date or a subset of current repo.
"""
try: try:
return ((self.tipnode == repo.changelog.node(self.tiprev)) return (
and (self.filteredhash == \ self.tipnode == repo.changelog.node(self.tiprev) and
scmutil.filteredhash(repo, self.tiprev))) self.filteredhash == scmutil.filteredhash(repo, self.tiprev)
)
except IndexError: except IndexError:
return False return False
def _branchtip(self, heads): def _branchtip(self, heads):
'''Return tuple with last open head in heads and false, '''Return tuple with last open head in heads and false,
otherwise return last closed head and true.''' otherwise return last closed head and true.'''
tip = heads[-1] tip = heads[-1]
closed = True closed = True
return heads return heads
def iterbranches(self): def iterbranches(self):
for bn, heads in self.iteritems(): for bn, heads in self.iteritems():
yield (bn, heads) + self._branchtip(heads) yield (bn, heads) + self._branchtip(heads)
def copy(self): def copy(self):
"""return an deep copy of the branchcache object""" """return an deep copy of the branchcache object"""
return branchcache(self, self.tipnode, self.tiprev, self.filteredhash, return type(self)(
self._closednodes) self,
self.tipnode,
self.tiprev,
self.filteredhash,
self._closednodes
)
def write(self, repo): def write(self, repo):
try: try:
f = repo.cachevfs(_filename(repo), "w", atomictemp=True) f = repo.cachevfs(self._filename(repo), "w", atomictemp=True)
cachekey = [hex(self.tipnode), '%d' % self.tiprev] cachekey = [hex(self.tipnode), '%d' % self.tiprev]
if self.filteredhash is not None: if self.filteredhash is not None:
cachekey.append(hex(self.filteredhash)) cachekey.append(hex(self.filteredhash))
f.write(" ".join(cachekey) + '\n') f.write(" ".join(cachekey) + '\n')
nodecount = 0 nodecount = 0
for label, nodes in sorted(self.iteritems()): for label, nodes in sorted(self.iteritems()):
for node in nodes: for node in nodes:
nodecount += 1 nodecount += 1
self.tipnode = cl.node(tiprev) self.tipnode = cl.node(tiprev)
self.tiprev = tiprev self.tiprev = tiprev
self.filteredhash = scmutil.filteredhash(repo, self.tiprev) self.filteredhash = scmutil.filteredhash(repo, self.tiprev)
duration = util.timer() - starttime duration = util.timer() - starttime
repo.ui.log('branchcache', 'updated %s branch cache in %.4f seconds\n', repo.ui.log('branchcache', 'updated %s branch cache in %.4f seconds\n',
repo.filtername, duration) repo.filtername, duration)
self.write(repo)
class remotebranchcache(branchcache):
"""Branchmap info for a remote connection, should not write locally"""
def write(self, repo):
pass
# Revision branch info cache # Revision branch info cache
_rbcversion = '-v1' _rbcversion = '-v1'
_rbcnames = 'rbc-names' + _rbcversion _rbcnames = 'rbc-names' + _rbcversion
_rbcrevs = 'rbc-revs' + _rbcversion _rbcrevs = 'rbc-revs' + _rbcversion
# [4 byte hash prefix][4 byte branch name number with sign bit indicating open] # [4 byte hash prefix][4 byte branch name number with sign bit indicating open]
_rbcrecfmt = '>4sI' _rbcrecfmt = '>4sI'
_rbcrecsize = calcsize(_rbcrecfmt) _rbcrecsize = calcsize(_rbcrecfmt)

mercurial/discovery.py

headssum[branch] = (None, [], []) headssum[branch] = (None, [], [])
# C drop data about untouched branches: # C drop data about untouched branches:
for branch in remotebranches - touchedbranches: for branch in remotebranches - touchedbranches:
del headssum[branch] del headssum[branch]
# D. Update newmap with outgoing changes. # D. Update newmap with outgoing changes.
# This will possibly add new heads and remove existing ones. # This will possibly add new heads and remove existing ones.
newmap = branchmap.branchcache((branch, heads[1]) newmap = branchmap.remotebranchcache((branch, heads[1])
for branch, heads in headssum.iteritems() for branch, heads in headssum.iteritems()
if heads[0] is not None) if heads[0] is not None)
newmap.update(repo, (ctx.rev() for ctx in missingctx)) newmap.update(repo, (ctx.rev() for ctx in missingctx))
for branch, newheads in newmap.iteritems(): for branch, newheads in newmap.iteritems():
headssum[branch][1][:] = newheads headssum[branch][1][:] = newheads
for branch, items in headssum.iteritems(): for branch, items in headssum.iteritems():
for l in items: for l in items:
if l is not None: if l is not None:

mercurial/localrepo.py

self.ui.configbool('devel', 'check-locks')): self.ui.configbool('devel', 'check-locks')):
if util.safehasattr(self.svfs, 'vfs'): # this is filtervfs if util.safehasattr(self.svfs, 'vfs'): # this is filtervfs
self.svfs.vfs.audit = self._getsvfsward(self.svfs.vfs.audit) self.svfs.vfs.audit = self._getsvfsward(self.svfs.vfs.audit)
else: # standard vfs else: # standard vfs
self.svfs.audit = self._getsvfsward(self.svfs.audit) self.svfs.audit = self._getsvfsward(self.svfs.audit)
self._dirstatevalidatewarned = False self._dirstatevalidatewarned = False
self._branchcaches = {} self._branchcaches = branchmap.BranchMapCache()
self._revbranchcache = None self._revbranchcache = None
self._filterpats = {} self._filterpats = {}
self._datafilters = {} self._datafilters = {}
self._transref = self._lockref = self._wlockref = None self._transref = self._lockref = self._wlockref = None
# A cache for various files under .hg/ that tracks file changes, # A cache for various files under .hg/ that tracks file changes,
# (used by the filecache decorator) # (used by the filecache decorator)
# #
def nodebookmarks(self, node): def nodebookmarks(self, node):
"""return the list of bookmarks pointing to the specified node""" """return the list of bookmarks pointing to the specified node"""
return self._bookmarks.names(node) return self._bookmarks.names(node)
def branchmap(self): def branchmap(self):
'''returns a dictionary {branch: [branchheads]} with branchheads '''returns a dictionary {branch: [branchheads]} with branchheads
ordered by increasing revision number''' ordered by increasing revision number'''
branchmap.updatecache(self) return self._branchcaches[self]
return self._branchcaches[self.filtername]
@unfilteredmethod @unfilteredmethod
def revbranchcache(self): def revbranchcache(self):
if not self._revbranchcache: if not self._revbranchcache:
self._revbranchcache = branchmap.revbranchcache(self.unfiltered()) self._revbranchcache = branchmap.revbranchcache(self.unfiltered())
return self._revbranchcache return self._revbranchcache
def branchtip(self, branch, ignoremissing=False): def branchtip(self, branch, ignoremissing=False):
up-to-date data. Even the ones usually loaded more lazily. up-to-date data. Even the ones usually loaded more lazily.
""" """
if tr is not None and tr.hookargs.get('source') == 'strip': if tr is not None and tr.hookargs.get('source') == 'strip':
# During strip, many caches are invalid but # During strip, many caches are invalid but
# later call to `destroyed` will refresh them. # later call to `destroyed` will refresh them.
return return
if tr is None or tr.changes['origrepolen'] < len(self): if tr is None or tr.changes['origrepolen'] < len(self):
# updating the unfiltered branchmap should refresh all the others, # accessing the 'ser ved' branchmap should refresh all the others,
self.ui.debug('updating the branch cache\n') self.ui.debug('updating the branch cache\n')
branchmap.updatecache(self.filtered('served')) self.filtered('served').branchmap()
if full: if full:
rbc = self.revbranchcache() rbc = self.revbranchcache()
for r in self.changelog: for r in self.changelog:
rbc.branchinfo(r) rbc.branchinfo(r)
rbc.write() rbc.write()
# ensure the working copy parents are in the manifestfulltextcache # ensure the working copy parents are in the manifestfulltextcache
for ctx in self['.'].parents(): for ctx in self['.'].parents():
ctx.manifest() # accessing the manifest is enough ctx.manifest() # accessing the manifest is enough
def invalidatecaches(self): def invalidatecaches(self):
if r'_tagscache' in vars(self): if r'_tagscache' in vars(self):
# can't use delattr on proxy # can't use delattr on proxy
del self.__dict__[r'_tagscache'] del self.__dict__[r'_tagscache']
self.unfiltered()._branchcaches.clear() self._branchcaches.clear()
self.invalidatevolatilesets() self.invalidatevolatilesets()
self._sparsesignaturecache.clear() self._sparsesignaturecache.clear()
def invalidatevolatilesets(self): def invalidatevolatilesets(self):
self.filteredrevcache.clear() self.filteredrevcache.clear()
obsolete.clearobscaches(self) obsolete.clearobscaches(self)
def invalidatedirstate(self): def invalidatedirstate(self):

mercurial/statichttprepo.py

# statichttprepo.py - simple http repository class for mercurial # statichttprepo.py - simple http repository class for mercurial
# #
# This provides read-only repo access to repositories exported via static http # This provides read-only repo access to repositories exported via static http
# #
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import errno import errno
from .i18n import _ from .i18n import _
from . import ( from . import (
branchmap,
changelog, changelog,
error, error,
localrepo, localrepo,
manifest, manifest,
namespaces, namespaces,
pathutil, pathutil,
url, url,
util, util,
self._filecache = {} self._filecache = {}
self.requirements = requirements self.requirements = requirements
rootmanifest = manifest.manifestrevlog(self.svfs) rootmanifest = manifest.manifestrevlog(self.svfs)
self.manifestlog = manifest.manifestlog(self.svfs, self, rootmanifest) self.manifestlog = manifest.manifestlog(self.svfs, self, rootmanifest)
self.changelog = changelog.changelog(self.svfs) self.changelog = changelog.changelog(self.svfs)
self._tags = None self._tags = None
self.nodetagscache = None self.nodetagscache = None
self._branchcaches = {} self._branchcaches = branchmap.BranchMapCache()
self._revbranchcache = None self._revbranchcache = None
self.encodepats = None self.encodepats = None
self.decodepats = None self.decodepats = None
self._transref = None self._transref = None
def _restrictcapabilities(self, caps): def _restrictcapabilities(self, caps):
caps = super(statichttprepository, self)._restrictcapabilities(caps) caps = super(statichttprepository, self)._restrictcapabilities(caps)
return caps.difference(["pushkey"]) return caps.difference(["pushkey"])

mercurial/streamclone.py

# requirements from the streamed-in repository # requirements from the streamed-in repository
repo.requirements = requirements | ( repo.requirements = requirements | (
repo.requirements - repo.supportedformats) repo.requirements - repo.supportedformats)
repo.svfs.options = localrepo.resolvestorevfsoptions( repo.svfs.options = localrepo.resolvestorevfsoptions(
repo.ui, repo.requirements, repo.features) repo.ui, repo.requirements, repo.features)
repo._writerequirements() repo._writerequirements()
if rbranchmap: if rbranchmap:
branchmap.replacecache(repo, rbranchmap) repo._branchcaches.replace(repo, rbranchmap)
repo.invalidate() repo.invalidate()
def allowservergeneration(repo): def allowservergeneration(repo):
"""Whether streaming clones are allowed from the server.""" """Whether streaming clones are allowed from the server."""
if repository.REPO_FEATURE_STREAM_CLONE not in repo.features: if repository.REPO_FEATURE_STREAM_CLONE not in repo.features:
return False return False