This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5259

py3: fix keyword arguments handling in hgext/remotefilelog/
ClosedPublic

Authored by pulkit on Nov 13 2018, 10:27 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG13d4ad8d7801: py3: fix keyword arguments handling in hgext/remotefilelog/
Summary

Keys of kwargs on Python 3 should be strings. This patch fixes them by appending
r'' prefixes, and using pycompat.byteskwargs() and pycompat.strkwargs().

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

pulkit created this revision.Nov 13 2018, 10:27 AM
Closed by commit rHG13d4ad8d7801: py3: fix keyword arguments handling in hgext/remotefilelog/ (authored by pulkit). · Explain WhyNov 13 2018, 1:49 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 12522

hgext/remotefilelog/__init__.py

exchange, exchange,
extensions, extensions,
hg, hg,
localrepo, localrepo,
match, match,
merge, merge,
node as nodemod, node as nodemod,
patch, patch,
pycompat,
registrar, registrar,
repair, repair,
repoview, repoview,
revset, revset,
scmutil, scmutil,
smartset, smartset,
streamclone, streamclone,
templatekw, templatekw,
debugcommands.debugindex) debugcommands.debugindex)
extensions.wrapcommand(commands.table, 'debugindexdot', extensions.wrapcommand(commands.table, 'debugindexdot',
debugcommands.debugindexdot) debugcommands.debugindexdot)
extensions.wrapcommand(commands.table, 'log', log) extensions.wrapcommand(commands.table, 'log', log)
extensions.wrapcommand(commands.table, 'pull', pull) extensions.wrapcommand(commands.table, 'pull', pull)
# Prevent 'hg manifest --all' # Prevent 'hg manifest --all'
def _manifest(orig, ui, repo, *args, **opts): def _manifest(orig, ui, repo, *args, **opts):
if (isenabled(repo) and opts.get('all')): if (isenabled(repo) and opts.get(r'all')):
raise error.Abort(_("--all is not supported in a shallow repo")) raise error.Abort(_("--all is not supported in a shallow repo"))
return orig(ui, repo, *args, **opts) return orig(ui, repo, *args, **opts)
extensions.wrapcommand(commands.table, "manifest", _manifest) extensions.wrapcommand(commands.table, "manifest", _manifest)
# Wrap remotefilelog with lfs code # Wrap remotefilelog with lfs code
def _lfsloaded(loaded=False): def _lfsloaded(loaded=False):
lfsmod = None lfsmod = None
try: try:
lfsmod = extensions.find('lfs') lfsmod = extensions.find('lfs')
except KeyError: except KeyError:
pass pass
if lfsmod: if lfsmod:
lfsmod.wrapfilelog(remotefilelog.remotefilelog) lfsmod.wrapfilelog(remotefilelog.remotefilelog)
fileserverclient._lfsmod = lfsmod fileserverclient._lfsmod = lfsmod
extensions.afterloaded('lfs', _lfsloaded) extensions.afterloaded('lfs', _lfsloaded)
# debugdata needs remotefilelog.len to work # debugdata needs remotefilelog.len to work
extensions.wrapcommand(commands.table, 'debugdata', debugdatashallow) extensions.wrapcommand(commands.table, 'debugdata', debugdatashallow)
def cloneshallow(orig, ui, repo, *args, **opts): def cloneshallow(orig, ui, repo, *args, **opts):
if opts.get('shallow'): if opts.get(r'shallow'):
repos = [] repos = []
def pull_shallow(orig, self, *args, **kwargs): def pull_shallow(orig, self, *args, **kwargs):
if not isenabled(self): if not isenabled(self):
repos.append(self.unfiltered()) repos.append(self.unfiltered())
# set up the client hooks so the post-clone update works # set up the client hooks so the post-clone update works
setupclient(self.ui, self.unfiltered()) setupclient(self.ui, self.unfiltered())
# setupclient fixed the class on the repo itself # setupclient fixed the class on the repo itself
def setup_streamout(repo, remote): def setup_streamout(repo, remote):
# Replace remote.stream_out with a version that sends file # Replace remote.stream_out with a version that sends file
# patterns. # patterns.
def stream_out_shallow(orig): def stream_out_shallow(orig):
caps = remote.capabilities() caps = remote.capabilities()
if constants.NETWORK_CAP_LEGACY_SSH_GETFILES in caps: if constants.NETWORK_CAP_LEGACY_SSH_GETFILES in caps:
opts = {} opts = {}
if repo.includepattern: if repo.includepattern:
opts['includepattern'] = '\0'.join(repo.includepattern) opts[r'includepattern'] = '\0'.join(repo.includepattern)
if repo.excludepattern: if repo.excludepattern:
opts['excludepattern'] = '\0'.join(repo.excludepattern) opts[r'excludepattern'] = '\0'.join(repo.excludepattern)
return remote._callstream('stream_out_shallow', **opts) return remote._callstream('stream_out_shallow', **opts)
else: else:
return orig() return orig()
extensions.wrapfunction(remote, 'stream_out', stream_out_shallow) extensions.wrapfunction(remote, 'stream_out', stream_out_shallow)
def stream_wrap(orig, op): def stream_wrap(orig, op):
setup_streamout(op.repo, op.remote) setup_streamout(op.repo, op.remote)
return orig(op) return orig(op)
extensions.wrapfunction( extensions.wrapfunction(
requirements.add(constants.SHALLOWREPO_REQUIREMENT) requirements.add(constants.SHALLOWREPO_REQUIREMENT)
return supported, requirements return supported, requirements
extensions.wrapfunction( extensions.wrapfunction(
streamclone, 'canperformstreamclone', canperformstreamclone) streamclone, 'canperformstreamclone', canperformstreamclone)
try: try:
orig(ui, repo, *args, **opts) orig(ui, repo, *args, **opts)
finally: finally:
if opts.get('shallow'): if opts.get(r'shallow'):
for r in repos: for r in repos:
if util.safehasattr(r, 'fileservice'): if util.safehasattr(r, 'fileservice'):
r.fileservice.close() r.fileservice.close()
def debugdatashallow(orig, *args, **kwds): def debugdatashallow(orig, *args, **kwds):
oldlen = remotefilelog.remotefilelog.__len__ oldlen = remotefilelog.remotefilelog.__len__
try: try:
remotefilelog.remotefilelog.__len__ = lambda x: 1 remotefilelog.remotefilelog.__len__ = lambda x: 1
sharedcache.gc(keepkeys) sharedcache.gc(keepkeys)
elif not filesrepacked: elif not filesrepacked:
ui.warn(_("warning: no valid repos in repofile\n")) ui.warn(_("warning: no valid repos in repofile\n"))
def log(orig, ui, repo, *pats, **opts): def log(orig, ui, repo, *pats, **opts):
if not isenabled(repo): if not isenabled(repo):
return orig(ui, repo, *pats, **opts) return orig(ui, repo, *pats, **opts)
follow = opts.get('follow') follow = opts.get(r'follow')
revs = opts.get('rev') revs = opts.get(r'rev')
if pats: if pats:
# Force slowpath for non-follow patterns and follows that start from # Force slowpath for non-follow patterns and follows that start from
# non-working-copy-parent revs. # non-working-copy-parent revs.
if not follow or revs: if not follow or revs:
# This forces the slowpath # This forces the slowpath
opts['removed'] = True opts[r'removed'] = True
# If this is a non-follow log without any revs specified, recommend that # If this is a non-follow log without any revs specified, recommend that
# the user add -f to speed it up. # the user add -f to speed it up.
if not follow and not revs: if not follow and not revs:
match, pats = scmutil.matchandpats(repo['.'], pats, opts) match, pats = scmutil.matchandpats(repo['.'], pats,
pycompat.byteskwargs(opts))
isfile = not match.anypats() isfile = not match.anypats()
if isfile: if isfile:
for file in match.files(): for file in match.files():
if not os.path.isfile(repo.wjoin(file)): if not os.path.isfile(repo.wjoin(file)):
isfile = False isfile = False
break break
if isfile: if isfile:
Prefetchs file revisions for the specified revs and stores them in the Prefetchs file revisions for the specified revs and stores them in the
local remotefilelog cache. If no rev is specified, the default rev is local remotefilelog cache. If no rev is specified, the default rev is
used which is the union of dot, draft, pullprefetch and bgprefetchrev. used which is the union of dot, draft, pullprefetch and bgprefetchrev.
File names or patterns can be used to limit which files are downloaded. File names or patterns can be used to limit which files are downloaded.
Return 0 on success. Return 0 on success.
""" """
opts = pycompat.byteskwargs(opts)
if not isenabled(repo): if not isenabled(repo):
raise error.Abort(_("repo is not shallow")) raise error.Abort(_("repo is not shallow"))
opts = resolveprefetchopts(ui, opts) opts = resolveprefetchopts(ui, opts)
revs = scmutil.revrange(repo, opts.get('rev')) revs = scmutil.revrange(repo, opts.get('rev'))
repo.prefetch(revs, opts.get('base'), pats, opts) repo.prefetch(revs, opts.get('base'), pats, opts)
# Run repack in background # Run repack in background
if opts.get('repack'): if opts.get('repack'):
repackmod.backgroundrepack(repo, incremental=True) repackmod.backgroundrepack(repo, incremental=True)
@command('repack', [ @command('repack', [
('', 'background', None, _('run in a background process'), None), ('', 'background', None, _('run in a background process'), None),
('', 'incremental', None, _('do an incremental repack'), None), ('', 'incremental', None, _('do an incremental repack'), None),
('', 'packsonly', None, _('only repack packs (skip loose objects)'), None), ('', 'packsonly', None, _('only repack packs (skip loose objects)'), None),
], _('hg repack [OPTIONS]')) ], _('hg repack [OPTIONS]'))
def repack_(ui, repo, *pats, **opts): def repack_(ui, repo, *pats, **opts):
if opts.get('background'): if opts.get(r'background'):
repackmod.backgroundrepack(repo, incremental=opts.get('incremental'), repackmod.backgroundrepack(repo, incremental=opts.get(r'incremental'),
packsonly=opts.get('packsonly', False)) packsonly=opts.get(r'packsonly', False))
return return
options = {'packsonly': opts.get('packsonly')} options = {'packsonly': opts.get(r'packsonly')}
try: try:
if opts.get('incremental'): if opts.get(r'incremental'):
repackmod.incrementalrepack(repo, options=options) repackmod.incrementalrepack(repo, options=options)
else: else:
repackmod.fullrepack(repo, options=options) repackmod.fullrepack(repo, options=options)
except repackmod.RepackAlreadyRunning as ex: except repackmod.RepackAlreadyRunning as ex:
# Don't propogate the exception if the repack is already in # Don't propogate the exception if the repack is already in
# progress, since we want the command to exit 0. # progress, since we want the command to exit 0.
repo.ui.warn('%s\n' % ex) repo.ui.warn('%s\n' % ex)

hgext/remotefilelog/basestore.py

float(size) / 1024.0 / 1024.0 / 1024.0)) float(size) / 1024.0 / 1024.0 / 1024.0))
class baseunionstore(object): class baseunionstore(object):
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
# If one of the functions that iterates all of the stores is about to # If one of the functions that iterates all of the stores is about to
# throw a KeyError, try this many times with a full refresh between # throw a KeyError, try this many times with a full refresh between
# attempts. A repack operation may have moved data from one store to # attempts. A repack operation may have moved data from one store to
# another while we were running. # another while we were running.
self.numattempts = kwargs.get('numretries', 0) + 1 self.numattempts = kwargs.get(r'numretries', 0) + 1
# If not-None, call this function on every retry and if the attempts are # If not-None, call this function on every retry and if the attempts are
# exhausted. # exhausted.
self.retrylog = kwargs.get('retrylog', None) self.retrylog = kwargs.get(r'retrylog', None)
def markforrefresh(self): def markforrefresh(self):
for store in self.stores: for store in self.stores:
if util.safehasattr(store, 'markforrefresh'): if util.safehasattr(store, 'markforrefresh'):
store.markforrefresh() store.markforrefresh()
@staticmethod @staticmethod
def retriable(fn): def retriable(fn):

hgext/remotefilelog/contentstore.py

# The actual delta or full text data. # The actual delta or full text data.
DATA = 4 DATA = 4
class unioncontentstore(basestore.baseunionstore): class unioncontentstore(basestore.baseunionstore):
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
super(unioncontentstore, self).__init__(*args, **kwargs) super(unioncontentstore, self).__init__(*args, **kwargs)
self.stores = args self.stores = args
self.writestore = kwargs.get('writestore') self.writestore = kwargs.get(r'writestore')
# If allowincomplete==True then the union store can return partial # If allowincomplete==True then the union store can return partial
# delta chains, otherwise it will throw a KeyError if a full # delta chains, otherwise it will throw a KeyError if a full
# deltachain can't be found. # deltachain can't be found.
self.allowincomplete = kwargs.get('allowincomplete', False) self.allowincomplete = kwargs.get(r'allowincomplete', False)
def get(self, name, node): def get(self, name, node):
"""Fetches the full text revision contents of the given name+node pair. """Fetches the full text revision contents of the given name+node pair.
If the full text doesn't exist, throws a KeyError. If the full text doesn't exist, throws a KeyError.
Under the hood, this uses getdeltachain() across all the stores to build Under the hood, this uses getdeltachain() across all the stores to build
up a full chain to produce the full text. up a full chain to produce the full text.
""" """

hgext/remotefilelog/debugcommands.py

extutil, extutil,
fileserverclient, fileserverclient,
historypack, historypack,
repack, repack,
shallowutil, shallowutil,
) )
def debugremotefilelog(ui, path, **opts): def debugremotefilelog(ui, path, **opts):
decompress = opts.get('decompress') decompress = opts.get(r'decompress')
size, firstnode, mapping = parsefileblob(path, decompress) size, firstnode, mapping = parsefileblob(path, decompress)
ui.status(_("size: %s bytes\n") % (size)) ui.status(_("size: %s bytes\n") % (size))
ui.status(_("path: %s \n") % (path)) ui.status(_("path: %s \n") % (path))
ui.status(_("key: %s \n") % (short(firstnode))) ui.status(_("key: %s \n") % (short(firstnode)))
ui.status(_("\n")) ui.status(_("\n"))
ui.status(_("%12s => %12s %13s %13s %12s\n") % ui.status(_("%12s => %12s %13s %13s %12s\n") %
meta['copyrev'] = hex(fctx.renamed()[1]) meta['copyrev'] = hex(fctx.renamed()[1])
r.add(fctx.data(), meta, t, fctx.linkrev(), p[0], p[1]) r.add(fctx.data(), meta, t, fctx.linkrev(), p[0], p[1])
return r return r
def debugindex(orig, ui, repo, file_=None, **opts): def debugindex(orig, ui, repo, file_=None, **opts):
"""dump the contents of an index file""" """dump the contents of an index file"""
if (opts.get('changelog') or if (opts.get(r'changelog') or
opts.get('manifest') or opts.get(r'manifest') or
opts.get('dir') or opts.get(r'dir') or
not shallowutil.isenabled(repo) or not shallowutil.isenabled(repo) or
not repo.shallowmatch(file_)): not repo.shallowmatch(file_)):
return orig(ui, repo, file_, **opts) return orig(ui, repo, file_, **opts)
r = buildtemprevlog(repo, file_) r = buildtemprevlog(repo, file_)
# debugindex like normal # debugindex like normal
format = opts.get('format', 0) format = opts.get('format', 0)
node = r.node(i) node = r.node(i)
pp = r.parents(node) pp = r.parents(node)
ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i)) ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i))
if pp[1] != nullid: if pp[1] != nullid:
ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i)) ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i))
ui.write("}\n") ui.write("}\n")
def verifyremotefilelog(ui, path, **opts): def verifyremotefilelog(ui, path, **opts):
decompress = opts.get('decompress') decompress = opts.get(r'decompress')
for root, dirs, files in os.walk(path): for root, dirs, files in os.walk(path):
for file in files: for file in files:
if file == "repos": if file == "repos":
continue continue
filepath = os.path.join(root, file) filepath = os.path.join(root, file)
size, firstnode, mapping = parsefileblob(filepath, decompress) size, firstnode, mapping = parsefileblob(filepath, decompress)
for p1, p2, linknode, copyfrom in mapping.itervalues(): for p1, p2, linknode, copyfrom in mapping.itervalues():
return size, firstnode, mapping return size, firstnode, mapping
def debugdatapack(ui, *paths, **opts): def debugdatapack(ui, *paths, **opts):
for path in paths: for path in paths:
if '.data' in path: if '.data' in path:
path = path[:path.index('.data')] path = path[:path.index('.data')]
ui.write("%s:\n" % path) ui.write("%s:\n" % path)
dpack = datapack.datapack(path) dpack = datapack.datapack(path)
node = opts.get('node') node = opts.get(r'node')
if node: if node:
deltachain = dpack.getdeltachain('', bin(node)) deltachain = dpack.getdeltachain('', bin(node))
dumpdeltachain(ui, deltachain, **opts) dumpdeltachain(ui, deltachain, **opts)
return return
if opts.get('long'): if opts.get(r'long'):
hashformatter = hex hashformatter = hex
hashlen = 42 hashlen = 42
else: else:
hashformatter = short hashformatter = short
hashlen = 14 hashlen = 14
lastfilename = None lastfilename = None
totaldeltasize = 0 totaldeltasize = 0

hgext/remotefilelog/fileserverclient.py

import threading import threading
import time import time
import zlib import zlib
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import bin, hex, nullid from mercurial.node import bin, hex, nullid
from mercurial import ( from mercurial import (
error, error,
pycompat,
revlog, revlog,
sshpeer, sshpeer,
util, util,
wireprotov1peer, wireprotov1peer,
) )
from mercurial.utils import procutil from mercurial.utils import procutil
from . import ( from . import (
def _sendrequest(self, command, args, **opts): def _sendrequest(self, command, args, **opts):
self._updatecallstreamopts(command, args) self._updatecallstreamopts(command, args)
return super(remotefilepeer, self)._sendrequest(command, args, return super(remotefilepeer, self)._sendrequest(command, args,
**opts) **opts)
def _callstream(self, command, **opts): def _callstream(self, command, **opts):
supertype = super(remotefilepeer, self) supertype = super(remotefilepeer, self)
if not util.safehasattr(supertype, '_sendrequest'): if not util.safehasattr(supertype, '_sendrequest'):
self._updatecallstreamopts(command, opts) self._updatecallstreamopts(command, pycompat.byteskwargs(opts))
return super(remotefilepeer, self)._callstream(command, **opts) return super(remotefilepeer, self)._callstream(command, **opts)
peer.__class__ = remotefilepeer peer.__class__ = remotefilepeer
class cacheconnection(object): class cacheconnection(object):
"""The connection for communicating with the remote cache. Performs """The connection for communicating with the remote cache. Performs
gets and sets by communicating with an external process that has the gets and sets by communicating with an external process that has the
cache-specific implementation. cache-specific implementation.

hgext/remotefilelog/metadatastore.py

from __future__ import absolute_import from __future__ import absolute_import
from mercurial.node import hex, nullid from mercurial.node import hex, nullid
from . import ( from . import (
basestore, basestore,
shallowutil, shallowutil,
) )
class unionmetadatastore(basestore.baseunionstore): class unionmetadatastore(basestore.baseunionstore):
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
super(unionmetadatastore, self).__init__(*args, **kwargs) super(unionmetadatastore, self).__init__(*args, **kwargs)
self.stores = args self.stores = args
self.writestore = kwargs.get('writestore') self.writestore = kwargs.get(r'writestore')
# If allowincomplete==True then the union store can return partial # If allowincomplete==True then the union store can return partial
# ancestor lists, otherwise it will throw a KeyError if a full # ancestor lists, otherwise it will throw a KeyError if a full
# history can't be found. # history can't be found.
self.allowincomplete = kwargs.get('allowincomplete', False) self.allowincomplete = kwargs.get(r'allowincomplete', False)
def getancestors(self, name, node, known=None): def getancestors(self, name, node, known=None):
"""Returns as many ancestors as we're aware of. """Returns as many ancestors as we're aware of.
return value: { return value: {
node: (p1, p2, linknode, copyfrom), node: (p1, p2, linknode, copyfrom),
... ...
} }

hgext/remotefilelog/remotefilectx.py

import time import time
from mercurial.node import bin, hex, nullid, nullrev from mercurial.node import bin, hex, nullid, nullrev
from mercurial import ( from mercurial import (
ancestor, ancestor,
context, context,
error, error,
phases, phases,
pycompat,
util, util,
) )
from . import shallowutil from . import shallowutil
propertycache = util.propertycache propertycache = util.propertycache
FASTLOG_TIMEOUT_IN_SECS = 0.5 FASTLOG_TIMEOUT_IN_SECS = 0.5
class remotefilectx(context.filectx): class remotefilectx(context.filectx):
inclusive = True # we skipped the real (revless) source inclusive = True # we skipped the real (revless) source
else: else:
revs = [srcrev] revs = [srcrev]
if self._verifylinknode(revs, linknode): if self._verifylinknode(revs, linknode):
return linknode return linknode
commonlogkwargs = { commonlogkwargs = {
'revs': ' '.join([hex(cl.node(rev)) for rev in revs]), r'revs': ' '.join([hex(cl.node(rev)) for rev in revs]),
'fnode': hex(fnode), r'fnode': hex(fnode),
'filepath': path, r'filepath': path,
'user': shallowutil.getusername(repo.ui), r'user': shallowutil.getusername(repo.ui),
'reponame': shallowutil.getreponame(repo.ui), r'reponame': shallowutil.getreponame(repo.ui),
} }
repo.ui.log('linkrevfixup', 'adjusting linknode', **commonlogkwargs) repo.ui.log('linkrevfixup', 'adjusting linknode', **commonlogkwargs)
pc = repo._phasecache pc = repo._phasecache
seenpublic = False seenpublic = False
iteranc = cl.ancestors(revs, inclusive=inclusive) iteranc = cl.ancestors(revs, inclusive=inclusive)
for ancrev in iteranc: for ancrev in iteranc:
logmsg = 'remotefilelog prefetching not found' logmsg = 'remotefilelog prefetching not found'
return None return None
except Exception as e: except Exception as e:
logmsg = 'remotefilelog prefetching failed (%s)' % e logmsg = 'remotefilelog prefetching failed (%s)' % e
return None return None
finally: finally:
elapsed = time.time() - start elapsed = time.time() - start
repo.ui.log('linkrevfixup', logmsg, elapsed=elapsed * 1000, repo.ui.log('linkrevfixup', logmsg, elapsed=elapsed * 1000,
**commonlogkwargs) **pycompat.strkwargs(commonlogkwargs))
def _verifylinknode(self, revs, linknode): def _verifylinknode(self, revs, linknode):
""" """
Check if a linknode is correct one for the current history. Check if a linknode is correct one for the current history.
That is, return True if the linkrev is the ancestor of any of the That is, return True if the linkrev is the ancestor of any of the
passed in revs, otherwise return False. passed in revs, otherwise return False.
r = remotefilectx(self._repo, f, fileid=n, r = remotefilectx(self._repo, f, fileid=n,
ancestormap=amap) ancestormap=amap)
return r return r
return None return None
def annotate(self, *args, **kwargs): def annotate(self, *args, **kwargs):
introctx = self introctx = self
prefetchskip = kwargs.pop('prefetchskip', None) prefetchskip = kwargs.pop(r'prefetchskip', None)
if prefetchskip: if prefetchskip:
# use introrev so prefetchskip can be accurately tested # use introrev so prefetchskip can be accurately tested
introrev = self.introrev() introrev = self.introrev()
if self.rev() != introrev: if self.rev() != introrev:
introctx = remotefilectx(self._repo, self._path, introctx = remotefilectx(self._repo, self._path,
changeid=introrev, changeid=introrev,
fileid=self._filenode, fileid=self._filenode,
filelog=self._filelog, filelog=self._filelog,

hgext/remotefilelog/shallowbundle.py

def makechangegroup(orig, repo, outgoing, version, source, *args, **kwargs): def makechangegroup(orig, repo, outgoing, version, source, *args, **kwargs):
if not shallowutil.isenabled(repo): if not shallowutil.isenabled(repo):
return orig(repo, outgoing, version, source, *args, **kwargs) return orig(repo, outgoing, version, source, *args, **kwargs)
original = repo.shallowmatch original = repo.shallowmatch
try: try:
# if serving, only send files the clients has patterns for # if serving, only send files the clients has patterns for
if source == 'serve': if source == 'serve':
bundlecaps = kwargs.get('bundlecaps') bundlecaps = kwargs.get(r'bundlecaps')
includepattern = None includepattern = None
excludepattern = None excludepattern = None
for cap in (bundlecaps or []): for cap in (bundlecaps or []):
if cap.startswith("includepattern="): if cap.startswith("includepattern="):
raw = cap[len("includepattern="):] raw = cap[len("includepattern="):]
if raw: if raw:
includepattern = raw.split('\0') includepattern = raw.split('\0')
elif cap.startswith("excludepattern="): elif cap.startswith("excludepattern="):

hgext/remotefilelog/shallowutil.py

result = {} result = {}
for k, v in dict.iteritems(): for k, v in dict.iteritems():
result[prefix + k] = v result[prefix + k] = v
return result return result
def reportpackmetrics(ui, prefix, *stores): def reportpackmetrics(ui, prefix, *stores):
dicts = [s.getmetrics() for s in stores] dicts = [s.getmetrics() for s in stores]
dict = prefixkeys(sumdicts(*dicts), prefix + '_') dict = prefixkeys(sumdicts(*dicts), prefix + '_')
ui.log(prefix + "_packsizes", "", **dict) ui.log(prefix + "_packsizes", "", **pycompat.strkwargs(dict))
def _parsepackmeta(metabuf): def _parsepackmeta(metabuf):
"""parse datapack meta, bytes (<metadata-list>) -> dict """parse datapack meta, bytes (<metadata-list>) -> dict
The dict contains raw content - both keys and values are strings. The dict contains raw content - both keys and values are strings.
Upper-level business may want to convert some of them to other types like Upper-level business may want to convert some of them to other types like
integers, on their own. integers, on their own.