This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4536

hg: recognize include and exclude patterns when cloning
ClosedPublic

Authored by indygreg on Sep 11 2018, 8:27 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG65b5900f30be: hg: recognize include and exclude patterns when cloning
Summary

This commit teaches clone() to accept arguments defining file
patterns to clone. This is the first step in teaching core code
about the existence of a narrow clone.

Right now, we only perform validation of the arguments and pass
additional options into createopts to influence repository
creation. Nothing of consequence happens with that creation option
yet, however.

For now, arbitrary restrictions exist, such as not allowing patterns
for shared repos and disabling local copies when patterns are
defined. We can potentially lift these restrictions in the future
once partial clone/storage support is more flushed out. I figure
it is best to reduce the surface area for bugs for the time being.

It may seem weird to prefix these arguments with "store." However,
clone is effectively pull + update and file patterns could apply to
both the store and the working directory. The prefix is there to
disambiguate in the future when this function may want to use
different sets of patterns for the store and working directory.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

PathPackages
Mmercurial/hg.py (49 lines)

Diff 10913

mercurial/hg.py

exchange, exchange,
extensions, extensions,
httppeer, httppeer,
localrepo, localrepo,
lock, lock,
logcmdutil, logcmdutil,
logexchange, logexchange,
merge as mergemod, merge as mergemod,
narrowspec,
node, node,
phases, phases,
scmutil, scmutil,
sshpeer, sshpeer,
statichttprepo, statichttprepo,
ui as uimod, ui as uimod,
unionrepo, unionrepo,
url, url,
srcbranchcache = srcrepo.vfs.join('cache/%s' % fname) srcbranchcache = srcrepo.vfs.join('cache/%s' % fname)
dstbranchcache = os.path.join(dstcachedir, fname) dstbranchcache = os.path.join(dstcachedir, fname)
if os.path.exists(srcbranchcache): if os.path.exists(srcbranchcache):
if not os.path.exists(dstcachedir): if not os.path.exists(dstcachedir):
os.mkdir(dstcachedir) os.mkdir(dstcachedir)
util.copyfile(srcbranchcache, dstbranchcache) util.copyfile(srcbranchcache, dstbranchcache)
def clone(ui, peeropts, source, dest=None, pull=False, revs=None, def clone(ui, peeropts, source, dest=None, pull=False, revs=None,
update=True, stream=False, branch=None, shareopts=None): update=True, stream=False, branch=None, shareopts=None,
storeincludepats=None, storeexcludepats=None):
"""Make a copy of an existing repository. """Make a copy of an existing repository.
Create a copy of an existing repository in a new directory. The Create a copy of an existing repository in a new directory. The
source and destination are URLs, as passed to the repository source and destination are URLs, as passed to the repository
function. Returns a pair of repository peers, the source and function. Returns a pair of repository peers, the source and
newly created destination. newly created destination.
The location of the source is added to the new repository's The location of the source is added to the new repository's
branch: branches to clone branch: branches to clone
shareopts: dict of options to control auto sharing behavior. The "pool" key shareopts: dict of options to control auto sharing behavior. The "pool" key
activates auto sharing mode and defines the directory for stores. The activates auto sharing mode and defines the directory for stores. The
"mode" key determines how to construct the directory name of the shared "mode" key determines how to construct the directory name of the shared
repository. "identity" means the name is derived from the node of the first repository. "identity" means the name is derived from the node of the first
changeset in the repository. "remote" means the name is derived from the changeset in the repository. "remote" means the name is derived from the
remote's path/URL. Defaults to "identity." remote's path/URL. Defaults to "identity."
storeincludepats and storeexcludepats: sets of file patterns to include and
exclude in the repository copy, respectively. If not defined, all files
will be included (a "full" clone). Otherwise a "narrow" clone containing
only the requested files will be performed. If ``storeincludepats`` is not
defined but ``storeexcludepats`` is, ``storeincludepats`` is assumed to be
``path:.``. If both are empty sets, no files will be cloned.
""" """
if isinstance(source, bytes): if isinstance(source, bytes):
origsource = ui.expandpath(source) origsource = ui.expandpath(source)
source, branches = parseurl(origsource, branch) source, branches = parseurl(origsource, branch)
srcpeer = peer(ui, peeropts, source) srcpeer = peer(ui, peeropts, source)
else: else:
srcpeer = source.peer() # in case we were called with a localrepo srcpeer = source.peer() # in case we were called with a localrepo
destvfs = vfsmod.vfs(dest, expandpath=True) destvfs = vfsmod.vfs(dest, expandpath=True)
if destvfs.lexists(): if destvfs.lexists():
if not destvfs.isdir(): if not destvfs.isdir():
raise error.Abort(_("destination '%s' already exists") % dest) raise error.Abort(_("destination '%s' already exists") % dest)
elif destvfs.listdir(): elif destvfs.listdir():
raise error.Abort(_("destination '%s' is not empty") % dest) raise error.Abort(_("destination '%s' is not empty") % dest)
createopts = {}
narrow = False
if storeincludepats is not None:
narrowspec.validatepatterns(storeincludepats)
narrow = True
if storeexcludepats is not None:
narrowspec.validatepatterns(storeexcludepats)
narrow = True
if narrow:
# Include everything by default if only exclusion patterns defined.
if storeexcludepats and not storeincludepats:
storeincludepats = {'path:.'}
createopts['narrowfiles'] = True
shareopts = shareopts or {} shareopts = shareopts or {}
sharepool = shareopts.get('pool') sharepool = shareopts.get('pool')
sharenamemode = shareopts.get('mode') sharenamemode = shareopts.get('mode')
if sharepool and islocal(dest): if sharepool and islocal(dest):
sharepath = None sharepath = None
if sharenamemode == 'identity': if sharenamemode == 'identity':
# Resolve the name from the initial changeset in the remote # Resolve the name from the initial changeset in the remote
# repository. This returns nullid when the remote is empty. It # repository. This returns nullid when the remote is empty. It
'unable to resolve identity of remote)\n')) 'unable to resolve identity of remote)\n'))
elif sharenamemode == 'remote': elif sharenamemode == 'remote':
sharepath = os.path.join( sharepath = os.path.join(
sharepool, node.hex(hashlib.sha1(source).digest())) sharepool, node.hex(hashlib.sha1(source).digest()))
else: else:
raise error.Abort(_('unknown share naming mode: %s') % raise error.Abort(_('unknown share naming mode: %s') %
sharenamemode) sharenamemode)
# TODO this is a somewhat arbitrary restriction.
if narrow:
ui.status(_('(pooled storage not supported for narrow clones)\n'))
sharepath = None
if sharepath: if sharepath:
return clonewithshare(ui, peeropts, sharepath, source, srcpeer, return clonewithshare(ui, peeropts, sharepath, source, srcpeer,
dest, pull=pull, rev=revs, update=update, dest, pull=pull, rev=revs, update=update,
stream=stream) stream=stream)
srclock = destlock = cleandir = None srclock = destlock = cleandir = None
srcrepo = srcpeer.local() srcrepo = srcpeer.local()
try: try:
abspath = origsource abspath = origsource
if islocal(origsource): if islocal(origsource):
abspath = os.path.abspath(util.urllocalpath(origsource)) abspath = os.path.abspath(util.urllocalpath(origsource))
if islocal(dest): if islocal(dest):
cleandir = dest cleandir = dest
copy = False copy = False
if (srcrepo and srcrepo.cancopy() and islocal(dest) if (srcrepo and srcrepo.cancopy() and islocal(dest)
and not phases.hassecret(srcrepo)): and not phases.hassecret(srcrepo)):
copy = not pull and not revs copy = not pull and not revs
# TODO this is a somewhat arbitrary restriction.
if narrow:
copy = False
if copy: if copy:
try: try:
# we use a lock here because if we race with commit, we # we use a lock here because if we race with commit, we
# can end up with extra data in the cloned revlogs that's # can end up with extra data in the cloned revlogs that's
# not pointed to by changesets, thus causing verify to # not pointed to by changesets, thus causing verify to
# fail # fail
srclock = srcrepo.lock(wait=False) srclock = srcrepo.lock(wait=False)
except error.LockError: except error.LockError:
# we need to re-init the repo after manually copying the data # we need to re-init the repo after manually copying the data
# into it # into it
destpeer = peer(srcrepo, peeropts, dest) destpeer = peer(srcrepo, peeropts, dest)
srcrepo.hook('outgoing', source='clone', srcrepo.hook('outgoing', source='clone',
node=node.hex(node.nullid)) node=node.hex(node.nullid))
else: else:
try: try:
destpeer = peer(srcrepo or ui, peeropts, dest, create=True)
# only pass ui when no srcrepo # only pass ui when no srcrepo
destpeer = peer(srcrepo or ui, peeropts, dest, create=True,
createopts=createopts)
except OSError as inst: except OSError as inst:
if inst.errno == errno.EEXIST: if inst.errno == errno.EEXIST:
cleandir = None cleandir = None
raise error.Abort(_("destination '%s' already exists") raise error.Abort(_("destination '%s' already exists")
% dest) % dest)
raise raise
if revs: if revs:
else: else:
stream = None stream = None
# internal config: ui.quietbookmarkmove # internal config: ui.quietbookmarkmove
overrides = {('ui', 'quietbookmarkmove'): True} overrides = {('ui', 'quietbookmarkmove'): True}
with local.ui.configoverride(overrides, 'clone'): with local.ui.configoverride(overrides, 'clone'):
exchange.pull(local, srcpeer, revs, exchange.pull(local, srcpeer, revs,
streamclonerequested=stream) streamclonerequested=stream)
elif srcrepo: elif srcrepo:
# TODO lift restriction once exchange.push() accepts narrow
# push.
if narrow:
raise error.Abort(_('narrow clone not available for '
'remote destinations'))
exchange.push(srcrepo, destpeer, revs=revs, exchange.push(srcrepo, destpeer, revs=revs,
bookmarks=srcrepo._bookmarks.keys()) bookmarks=srcrepo._bookmarks.keys())
else: else:
raise error.Abort(_("clone from remote to remote not supported") raise error.Abort(_("clone from remote to remote not supported")
) )
cleandir = None cleandir = None