hg.py
1664 lines
| 53.8 KiB
| text/x-python
|
PythonLexer
/ mercurial / hg.py
|
r0 | # hg.py - repository classes for mercurial | ||
# | ||||
|
r47575 | # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | ||
|
r2859 | # Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com> | ||
|
r0 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r0 | |||
|
r25939 | |||
import os | ||||
|
r49400 | import posixpath | ||
|
r25939 | import shutil | ||
|
r36799 | import stat | ||
|
r49326 | import weakref | ||
|
r25939 | |||
from .i18n import _ | ||||
|
r46729 | from .node import ( | ||
hex, | ||||
|
r47771 | sha1nodeconstants, | ||
|
r46729 | short, | ||
) | ||||
|
r43359 | from .pycompat import getattr | ||
|
r22837 | |||
|
r25939 | from . import ( | ||
bookmarks, | ||||
bundlerepo, | ||||
cmdutil, | ||||
|
r28501 | destutil, | ||
|
r25939 | discovery, | ||
error, | ||||
exchange, | ||||
extensions, | ||||
r47677 | graphmod, | |||
|
r25939 | httppeer, | ||
localrepo, | ||||
lock, | ||||
|
r35906 | logcmdutil, | ||
|
r35348 | logexchange, | ||
|
r25939 | merge as mergemod, | ||
|
r45383 | mergestate as mergestatemod, | ||
|
r39586 | narrowspec, | ||
|
r25939 | phases, | ||
|
r45932 | requirements, | ||
|
r25939 | scmutil, | ||
sshpeer, | ||||
statichttprepo, | ||||
ui as uimod, | ||||
unionrepo, | ||||
url, | ||||
util, | ||||
verify as verifymod, | ||||
|
r31218 | vfs as vfsmod, | ||
|
r25939 | ) | ||
r48079 | from .interfaces import repository as repositorymod | |||
|
r47518 | from .utils import ( | ||
hashutil, | ||||
stringutil, | ||||
r47669 | urlutil, | |||
|
r47518 | ) | ||
|
r43078 | |||
|
r25939 | release = lock.release | ||
|
r0 | |||
|
r29424 | # shared features | ||
|
r43347 | sharedbookmarks = b'bookmarks' | ||
|
r29424 | |||
|
r43346 | |||
|
r17191 | def addbranchrevs(lrepo, other, branches, revs): | ||
r50641 | if util.safehasattr(other, 'peer'): | |||
# a courtesy to callers using a localrepo for other | ||||
peer = other.peer() | ||||
else: | ||||
peer = other | ||||
|
r11322 | hashbranch, branches = branches | ||
if not hashbranch and not branches: | ||||
|
r22818 | x = revs or None | ||
|
r37499 | if revs: | ||
|
r22818 | y = revs[0] | ||
else: | ||||
y = None | ||||
return x, y | ||||
|
r24306 | if revs: | ||
revs = list(revs) | ||||
else: | ||||
revs = [] | ||||
|
r43347 | if not peer.capable(b'branchmap'): | ||
|
r11322 | if branches: | ||
|
r43347 | raise error.Abort(_(b"remote branch lookup not supported")) | ||
|
r11322 | revs.append(hashbranch) | ||
|
r10380 | return revs, revs[0] | ||
|
r37658 | |||
with peer.commandexecutor() as e: | ||||
|
r43347 | branchmap = e.callcommand(b'branchmap', {}).result() | ||
|
r11322 | |||
|
r13047 | def primary(branch): | ||
|
r43347 | if branch == b'.': | ||
|
r17191 | if not lrepo: | ||
|
r43347 | raise error.Abort(_(b"dirstate branch not accessible")) | ||
|
r13047 | branch = lrepo.dirstate.branch() | ||
if branch in branchmap: | ||||
|
r46729 | revs.extend(hex(r) for r in reversed(branchmap[branch])) | ||
|
r11322 | return True | ||
|
r10365 | else: | ||
|
r11322 | return False | ||
for branch in branches: | ||||
|
r13047 | if not primary(branch): | ||
|
r43347 | raise error.RepoLookupError(_(b"unknown branch '%s'") % branch) | ||
|
r11322 | if hashbranch: | ||
|
r13047 | if not primary(hashbranch): | ||
|
r11322 | revs.append(hashbranch) | ||
|
r10365 | return revs, revs[0] | ||
|
r43346 | |||
r50580 | def _isfile(path): | |||
try: | ||||
# we use os.stat() directly here instead of os.path.isfile() | ||||
# because the latter started returning `False` on invalid path | ||||
# exceptions starting in 3.8 and we care about handling | ||||
# invalid paths specially here. | ||||
st = os.stat(path) | ||||
except ValueError as e: | ||||
msg = stringutil.forcebytestr(e) | ||||
raise error.Abort(_(b'invalid path %s: %s') % (path, msg)) | ||||
except OSError: | ||||
return False | ||||
else: | ||||
return stat.S_ISREG(st.st_mode) | ||||
class LocalFactory: | ||||
"""thin wrapper to dispatch between localrepo and bundle repo""" | ||||
@staticmethod | ||||
def islocal(path: bytes) -> bool: | ||||
path = util.expandpath(urlutil.urllocalpath(path)) | ||||
return not _isfile(path) | ||||
@staticmethod | ||||
def instance(ui, path, *args, **kwargs): | ||||
path = util.expandpath(urlutil.urllocalpath(path)) | ||||
if _isfile(path): | ||||
cls = bundlerepo | ||||
else: | ||||
cls = localrepo | ||||
return cls.instance(ui, path, *args, **kwargs) | ||||
r50584 | repo_schemes = { | |||
|
r43347 | b'bundle': bundlerepo, | ||
b'union': unionrepo, | ||||
r50580 | b'file': LocalFactory, | |||
r50584 | } | |||
peer_schemes = { | ||||
|
r43347 | b'http': httppeer, | ||
b'https': httppeer, | ||||
b'ssh': sshpeer, | ||||
r50586 | b'static-http': statichttprepo, | |||
|
r14568 | } | ||
|
r43346 | |||
|
r14605 | def islocal(repo): | ||
|
r20355 | '''return true if repo (or path pointing to repo) is local''' | ||
|
r33018 | if isinstance(repo, bytes): | ||
r50644 | u = urlutil.url(repo) | |||
scheme = u.scheme or b'file' | ||||
if scheme in peer_schemes: | ||||
cls = peer_schemes[scheme] | ||||
elif scheme in repo_schemes: | ||||
cls = repo_schemes[scheme] | ||||
else: | ||||
cls = LocalFactory | ||||
r50583 | cls.instance # make sure we load the module | |||
if util.safehasattr(cls, 'islocal'): | ||||
return cls.islocal(repo) # pytype: disable=module-attr | ||||
return False | ||||
r50582 | repo.ui.deprecwarn(b"use obj.local() instead of islocal(obj)", b"6.4") | |||
|
r14605 | return repo.local() | ||
|
r43346 | |||
|
r42278 | def openpath(ui, path, sendaccept=True): | ||
|
r17887 | '''open path with open if local, url.open if remote''' | ||
r47669 | pathurl = urlutil.url(path, parsequery=False, parsefragment=False) | |||
|
r20354 | if pathurl.islocal(): | ||
|
r43347 | return util.posixfile(pathurl.localpath(), b'rb') | ||
|
r17887 | else: | ||
|
r42278 | return url.open(ui, path, sendaccept=sendaccept) | ||
|
r17887 | |||
|
r43346 | |||
|
r20858 | # a list of (ui, repo) functions called for wire peer initialization | ||
wirepeersetupfuncs = [] | ||||
|
r43346 | |||
r50579 | def _setup_repo_or_peer(ui, obj, presetupfuncs=None): | |||
|
r17191 | ui = getattr(obj, "ui", ui) | ||
|
r32379 | for f in presetupfuncs or []: | ||
f(ui, obj) | ||||
|
r41032 | ui.log(b'extension', b'- executing reposetup hooks\n') | ||
|
r43532 | with util.timedcm('all reposetup') as allreposetupstats: | ||
|
r39546 | for name, module in extensions.extensions(ui): | ||
|
r41032 | ui.log(b'extension', b' - running reposetup for %s\n', name) | ||
|
r39546 | hook = getattr(module, 'reposetup', None) | ||
if hook: | ||||
|
r43532 | with util.timedcm('reposetup %r', name) as stats: | ||
|
r39546 | hook(ui, obj) | ||
r50579 | msg = b' > reposetup for %s took %s\n' | |||
ui.log(b'extension', msg, name, stats) | ||||
|
r41032 | ui.log(b'extension', b'> all reposetup took %s\n', allreposetupstats) | ||
|
r20858 | if not obj.local(): | ||
for f in wirepeersetupfuncs: | ||||
f(ui, obj) | ||||
|
r17191 | |||
|
r43346 | |||
def repository( | ||||
|
r43347 | ui, | ||
path=b'', | ||||
create=False, | ||||
presetupfuncs=None, | ||||
intents=None, | ||||
createopts=None, | ||||
|
r43346 | ): | ||
|
r17191 | """return a repository object for the specified path""" | ||
r50588 | scheme = urlutil.url(path).scheme | |||
if scheme is None: | ||||
scheme = b'file' | ||||
cls = repo_schemes.get(scheme) | ||||
if cls is None: | ||||
if scheme in peer_schemes: | ||||
raise error.Abort(_(b"repository '%s' is not local") % path) | ||||
cls = LocalFactory | ||||
repo = cls.instance( | ||||
|
r43346 | ui, | ||
path, | ||||
create, | ||||
intents=intents, | ||||
createopts=createopts, | ||||
) | ||||
r50588 | _setup_repo_or_peer(ui, repo, presetupfuncs=presetupfuncs) | |||
|
r43347 | return repo.filtered(b'visible') | ||
|
r14605 | |||
|
r43346 | |||
|
r39585 | def peer(uiorrepo, opts, path, create=False, intents=None, createopts=None): | ||
|
r14554 | '''return a repository peer for the specified path''' | ||
|
r14839 | rui = remoteui(uiorrepo, opts) | ||
r50602 | if util.safehasattr(path, 'url'): | |||
# this is a urlutil.path object | ||||
scheme = path.url.scheme # pytype: disable=attribute-error | ||||
# XXX for now we don't do anything more than that | ||||
path = path.loc # pytype: disable=attribute-error | ||||
else: | ||||
scheme = urlutil.url(path).scheme | ||||
r50587 | if scheme in peer_schemes: | |||
cls = peer_schemes[scheme] | ||||
peer = cls.instance( | ||||
rui, | ||||
path, | ||||
create, | ||||
intents=intents, | ||||
createopts=createopts, | ||||
) | ||||
_setup_repo_or_peer(rui, peer) | ||||
else: | ||||
# this is a repository | ||||
repo = repository( | ||||
rui, | ||||
path, | ||||
create, | ||||
intents=intents, | ||||
createopts=createopts, | ||||
) | ||||
peer = repo.peer() | ||||
return peer | ||||
|
r43346 | |||
|
r14554 | |||
|
r2719 | def defaultdest(source): | ||
|
r46554 | """return default destination of clone if none is given | ||
|
r20799 | |||
|
r34133 | >>> defaultdest(b'foo') | ||
|
r20799 | 'foo' | ||
|
r34133 | >>> defaultdest(b'/foo/bar') | ||
|
r20799 | 'bar' | ||
|
r34133 | >>> defaultdest(b'/') | ||
|
r20799 | '' | ||
|
r34133 | >>> defaultdest(b'') | ||
|
r20800 | '' | ||
|
r34133 | >>> defaultdest(b'http://example.org/') | ||
|
r20800 | '' | ||
|
r34133 | >>> defaultdest(b'http://example.org/foo/') | ||
|
r20799 | 'foo' | ||
|
r46554 | """ | ||
r47669 | path = urlutil.url(source).path | |||
|
r20800 | if not path: | ||
|
r43347 | return b'' | ||
|
r20800 | return os.path.basename(os.path.normpath(path)) | ||
|
r2774 | |||
|
r43346 | |||
|
r36177 | def sharedreposource(repo): | ||
"""Returns repository object for source repository of a shared repo. | ||||
If repo is not a shared repository, returns None. | ||||
""" | ||||
if repo.sharedpath == repo.path: | ||||
return None | ||||
|
r43347 | if util.safehasattr(repo, b'srcrepo') and repo.srcrepo: | ||
|
r36177 | return repo.srcrepo | ||
# the sharedpath always ends in the .hg; we want the path to the repo | ||||
source = repo.vfs.split(repo.sharedpath)[0] | ||||
r47670 | srcurl, branches = urlutil.parseurl(source) | |||
|
r36177 | srcrepo = repository(repo.ui, srcurl) | ||
repo.srcrepo = srcrepo | ||||
return srcrepo | ||||
|
r43346 | |||
def share( | ||||
ui, | ||||
source, | ||||
dest=None, | ||||
update=True, | ||||
bookmarks=True, | ||||
defaultpath=None, | ||||
relative=False, | ||||
): | ||||
|
r8800 | '''create a shared repository''' | ||
r50581 | not_local_msg = _(b'can only share local repositories') | |||
if util.safehasattr(source, 'local'): | ||||
if source.local() is None: | ||||
raise error.Abort(not_local_msg) | ||||
elif not islocal(source): | ||||
# XXX why are we getting bytes here ? | ||||
raise error.Abort(not_local_msg) | ||||
|
r8800 | |||
|
r8807 | if not dest: | ||
|
r10099 | dest = defaultdest(source) | ||
|
r9344 | else: | ||
r50639 | dest = urlutil.get_clone_path_obj(ui, dest).loc | |||
|
r8807 | |||
|
r36066 | if isinstance(source, bytes): | ||
r50639 | source_path = urlutil.get_clone_path_obj(ui, source) | |||
srcrepo = repository(ui, source_path.loc) | ||||
branches = (source_path.branch, []) | ||||
|
r10365 | rev, checkout = addbranchrevs(srcrepo, srcrepo, branches, None) | ||
|
r8800 | else: | ||
|
r17191 | srcrepo = source.local() | ||
|
r8800 | checkout = None | ||
|
r39885 | shareditems = set() | ||
if bookmarks: | ||||
shareditems.add(sharedbookmarks) | ||||
|
r43346 | r = repository( | ||
ui, | ||||
dest, | ||||
create=True, | ||||
createopts={ | ||||
|
r43347 | b'sharedrepo': srcrepo, | ||
b'sharedrelative': relative, | ||||
b'shareditems': shareditems, | ||||
|
r43346 | }, | ||
) | ||||
|
r8800 | |||
|
r39885 | postshare(srcrepo, r, defaultpath=defaultpath) | ||
|
r40609 | r = repository(ui, dest) | ||
|
r28632 | _postshareupdate(r, update, checkout=checkout) | ||
|
r34816 | return r | ||
|
r8800 | |||
|
r43346 | |||
|
r46057 | def _prependsourcehgrc(repo): | ||
|
r46554 | """copies the source repo config and prepend it in current repo .hg/hgrc | ||
|
r46057 | on unshare. This is only done if the share was perfomed using share safe | ||
method where we share config of source in shares""" | ||||
srcvfs = vfsmod.vfs(repo.sharedpath) | ||||
dstvfs = vfsmod.vfs(repo.path) | ||||
if not srcvfs.exists(b'hgrc'): | ||||
return | ||||
currentconfig = b'' | ||||
if dstvfs.exists(b'hgrc'): | ||||
currentconfig = dstvfs.read(b'hgrc') | ||||
with dstvfs(b'hgrc', b'wb') as fp: | ||||
sourceconfig = srcvfs.read(b'hgrc') | ||||
fp.write(b"# Config copied from shared source\n") | ||||
fp.write(sourceconfig) | ||||
fp.write(b'\n') | ||||
fp.write(currentconfig) | ||||
|
r34879 | def unshare(ui, repo): | ||
"""convert a shared repository to a normal one | ||||
Copy the store data to the repo and remove the sharedpath data. | ||||
|
r39642 | |||
Returns a new repository object representing the unshared repository. | ||||
The passed repository object is not usable after this function is | ||||
called. | ||||
|
r34879 | """ | ||
|
r41436 | with repo.lock(): | ||
|
r34879 | # we use locks here because if we race with commit, we | ||
# can end up with extra data in the cloned revlogs that's | ||||
# not pointed to by changesets, thus causing verify to | ||||
# fail | ||||
destlock = copystore(ui, repo, repo.path) | ||||
|
r41436 | with destlock or util.nullcontextmanager(): | ||
|
r46057 | if requirements.SHARESAFE_REQUIREMENT in repo.requirements: | ||
# we were sharing .hg/hgrc of the share source with the current | ||||
# repo. We need to copy that while unsharing otherwise it can | ||||
# disable hooks and other checks | ||||
_prependsourcehgrc(repo) | ||||
|
r34879 | |||
|
r43347 | sharefile = repo.vfs.join(b'sharedpath') | ||
util.rename(sharefile, sharefile + b'.old') | ||||
|
r41436 | |||
|
r45946 | repo.requirements.discard(requirements.SHARED_REQUIREMENT) | ||
repo.requirements.discard(requirements.RELATIVE_SHARED_REQUIREMENT) | ||||
|
r45666 | scmutil.writereporequirements(repo) | ||
|
r34879 | |||
|
r39642 | # Removing share changes some fundamental properties of the repo instance. | ||
# So we instantiate a new repo object and operate on it rather than | ||||
# try to keep the existing repo usable. | ||||
newrepo = repository(repo.baseui, repo.root, create=False) | ||||
|
r34879 | |||
|
r34880 | # TODO: figure out how to access subrepos that exist, but were previously | ||
# removed from .hgsub | ||||
|
r43347 | c = newrepo[b'.'] | ||
|
r34880 | subs = c.substate | ||
for s in sorted(subs): | ||||
c.sub(s).unshare() | ||||
|
r39642 | localrepo.poisonrepository(repo) | ||
return newrepo | ||||
|
r43346 | |||
|
r39885 | def postshare(sourcerepo, destrepo, defaultpath=None): | ||
|
r27354 | """Called after a new shared repo is created. | ||
The new repo only has a requirements file and pointer to the source. | ||||
This function configures additional shared data. | ||||
Extensions can wrap this function and write additional entries to | ||||
destrepo/.hg/shared to indicate additional pieces of data to be shared. | ||||
""" | ||||
|
r43347 | default = defaultpath or sourcerepo.ui.config(b'paths', b'default') | ||
|
r27354 | if default: | ||
|
r43387 | template = b'[paths]\ndefault = %s\n' | ||
|
r43347 | destrepo.vfs.write(b'hgrc', util.tonativeeol(template % default)) | ||
|
r45932 | if requirements.NARROW_REQUIREMENT in sourcerepo.requirements: | ||
|
r41072 | with destrepo.wlock(): | ||
|
r41265 | narrowspec.copytoworkingcopy(destrepo) | ||
|
r27354 | |||
|
r43346 | |||
|
r28632 | def _postshareupdate(repo, update, checkout=None): | ||
"""Maybe perform a working directory update after a shared repo is created. | ||||
``update`` can be a boolean or a revision to update to. | ||||
""" | ||||
if not update: | ||||
return | ||||
|
r43347 | repo.ui.status(_(b"updating working directory\n")) | ||
|
r28632 | if update is not True: | ||
checkout = update | ||||
|
r43347 | for test in (checkout, b'default', b'tip'): | ||
|
r28632 | if test is None: | ||
continue | ||||
try: | ||||
uprev = repo.lookup(test) | ||||
break | ||||
except error.RepoLookupError: | ||||
continue | ||||
_update(repo, uprev) | ||||
|
r43346 | |||
|
r15078 | def copystore(ui, srcrepo, destpath): | ||
|
r46554 | """copy files from store of srcrepo in destpath | ||
|
r15078 | |||
returns destlock | ||||
|
r46554 | """ | ||
|
r15078 | destlock = None | ||
try: | ||||
hardlink = None | ||||
|
r43347 | topic = _(b'linking') if hardlink else _(b'copying') | ||
with ui.makeprogress(topic, unit=_(b'files')) as progress: | ||||
|
r39425 | num = 0 | ||
srcpublishing = srcrepo.publishing() | ||||
srcvfs = vfsmod.vfs(srcrepo.sharedpath) | ||||
dstvfs = vfsmod.vfs(destpath) | ||||
for f in srcrepo.store.copylist(): | ||||
|
r43347 | if srcpublishing and f.endswith(b'phaseroots'): | ||
|
r39425 | continue | ||
dstbase = os.path.dirname(f) | ||||
if dstbase and not dstvfs.exists(dstbase): | ||||
dstvfs.mkdir(dstbase) | ||||
if srcvfs.exists(f): | ||||
|
r43347 | if f.endswith(b'data'): | ||
|
r39425 | # 'dstbase' may be empty (e.g. revlog format 0) | ||
|
r43347 | lockfile = os.path.join(dstbase, b"lock") | ||
|
r39425 | # lock to avoid premature writing to the target | ||
destlock = lock.lock(dstvfs, lockfile) | ||||
|
r43346 | hardlink, n = util.copyfiles( | ||
srcvfs.join(f), dstvfs.join(f), hardlink, progress | ||||
) | ||||
|
r39425 | num += n | ||
if hardlink: | ||||
|
r43347 | ui.debug(b"linked %d files\n" % num) | ||
|
r39425 | else: | ||
|
r43347 | ui.debug(b"copied %d files\n" % num) | ||
|
r15078 | return destlock | ||
|
r43346 | except: # re-raises | ||
|
r15078 | release(destlock) | ||
raise | ||||
|
r43346 | |||
def clonewithshare( | ||||
ui, | ||||
peeropts, | ||||
sharepath, | ||||
source, | ||||
srcpeer, | ||||
dest, | ||||
pull=False, | ||||
rev=None, | ||||
update=True, | ||||
stream=False, | ||||
): | ||||
|
r25761 | """Perform a clone using a shared repo. | ||
The store for the repository will be located at <sharepath>/.hg. The | ||||
specified revisions will be cloned or pulled from "source". A shared repo | ||||
will be created at "dest" and a working copy will be created if "update" is | ||||
True. | ||||
""" | ||||
revs = None | ||||
if rev: | ||||
|
r43347 | if not srcpeer.capable(b'lookup'): | ||
|
r43346 | raise error.Abort( | ||
_( | ||||
|
r43347 | b"src repository does not support " | ||
b"revision lookup and so doesn't " | ||||
b"support clone by revision" | ||||
|
r43346 | ) | ||
) | ||||
|
r37658 | |||
# TODO this is batchable. | ||||
remoterevs = [] | ||||
for r in rev: | ||||
with srcpeer.commandexecutor() as e: | ||||
|
r43347 | remoterevs.append( | ||
|
r46554 | e.callcommand( | ||
b'lookup', | ||||
{ | ||||
b'key': r, | ||||
}, | ||||
).result() | ||||
|
r43347 | ) | ||
|
r37658 | revs = remoterevs | ||
|
r25761 | |||
|
r28289 | # Obtain a lock before checking for or cloning the pooled repo otherwise | ||
# 2 clients may race creating or populating it. | ||||
pooldir = os.path.dirname(sharepath) | ||||
# lock class requires the directory to exist. | ||||
try: | ||||
util.makedir(pooldir, False) | ||||
|
r50200 | except FileExistsError: | ||
pass | ||||
|
r28289 | |||
|
r31218 | poolvfs = vfsmod.vfs(pooldir) | ||
|
r25761 | basename = os.path.basename(sharepath) | ||
|
r43347 | with lock.lock(poolvfs, b'%s.lock' % basename): | ||
|
r28289 | if os.path.exists(sharepath): | ||
|
r43346 | ui.status( | ||
|
r43347 | _(b'(sharing from existing pooled repository %s)\n') % basename | ||
|
r43346 | ) | ||
|
r28289 | else: | ||
|
r43347 | ui.status( | ||
_(b'(sharing from new pooled repository %s)\n') % basename | ||||
) | ||||
|
r28289 | # Always use pull mode because hardlinks in share mode don't work | ||
# well. Never update because working copies aren't necessary in | ||||
# share mode. | ||||
|
r43346 | clone( | ||
ui, | ||||
peeropts, | ||||
source, | ||||
dest=sharepath, | ||||
pull=True, | ||||
revs=rev, | ||||
update=False, | ||||
stream=stream, | ||||
) | ||||
|
r25761 | |||
|
r30041 | # Resolve the value to put in [paths] section for the source. | ||
if islocal(source): | ||||
r48426 | defaultpath = util.abspath(urlutil.urllocalpath(source)) | |||
|
r30041 | else: | ||
defaultpath = source | ||||
|
r25761 | sharerepo = repository(ui, path=sharepath) | ||
|
r43346 | destrepo = share( | ||
ui, | ||||
sharerepo, | ||||
dest=dest, | ||||
update=False, | ||||
bookmarks=False, | ||||
defaultpath=defaultpath, | ||||
) | ||||
|
r25761 | |||
# We need to perform a pull against the dest repo to fetch bookmarks | ||||
# and other non-store data that isn't shared by default. In the case of | ||||
# non-existing shared repo, this means we pull from the remote twice. This | ||||
# is a bit weird. But at the time it was implemented, there wasn't an easy | ||||
# way to pull just non-changegroup data. | ||||
exchange.pull(destrepo, srcpeer, heads=revs) | ||||
|
r28632 | _postshareupdate(destrepo, update) | ||
|
r25761 | return srcpeer, peer(ui, peeropts, dest) | ||
|
r43346 | |||
|
r46739 | # Recomputing caches is often slow on big repos, so copy them. | ||
r32492 | def _copycache(srcrepo, dstcachedir, fname): | |||
"""copy a cache from srcrepo to destcachedir (if it exists)""" | ||||
|
r46739 | srcfname = srcrepo.cachevfs.join(fname) | ||
dstfname = os.path.join(dstcachedir, fname) | ||||
if os.path.exists(srcfname): | ||||
r32492 | if not os.path.exists(dstcachedir): | |||
os.mkdir(dstcachedir) | ||||
|
r46739 | util.copyfile(srcfname, dstfname) | ||
r32492 | ||||
|
r43346 | |||
def clone( | ||||
ui, | ||||
peeropts, | ||||
source, | ||||
dest=None, | ||||
pull=False, | ||||
revs=None, | ||||
update=True, | ||||
stream=False, | ||||
branch=None, | ||||
shareopts=None, | ||||
storeincludepats=None, | ||||
storeexcludepats=None, | ||||
depth=None, | ||||
): | ||||
|
r2597 | """Make a copy of an existing repository. | ||
Create a copy of an existing repository in a new directory. The | ||||
source and destination are URLs, as passed to the repository | ||||
|
r17191 | function. Returns a pair of repository peers, the source and | ||
|
r2597 | newly created destination. | ||
The location of the source is added to the new repository's | ||||
.hg/hgrc file, as the default to be used for future pulls and | ||||
pushes. | ||||
If an exception is raised, the partly cloned/updated destination | ||||
repository will be deleted. | ||||
|
r2600 | |||
|
r2719 | Arguments: | ||
source: repository object or URL | ||||
|
r2597 | |||
dest: URL of destination repository to create (defaults to base | ||||
name of source repository) | ||||
|
r23545 | pull: always pull from source repository, even in local case or if the | ||
server prefers streaming | ||||
|
r2597 | |||
|
r2621 | stream: stream raw data uncompressed from repository (fast over | ||
LAN, slow over WAN) | ||||
|
r2613 | |||
|
r37279 | revs: revision to clone up to (implies pull=True) | ||
|
r2597 | |||
update: update working directory after clone completes, if | ||||
|
r6526 | destination is local repository (True means update to default rev, | ||
anything else is treated as a revision) | ||||
|
r10379 | |||
branch: branches to clone | ||||
|
r25761 | |||
shareopts: dict of options to control auto sharing behavior. The "pool" key | ||||
activates auto sharing mode and defines the directory for stores. The | ||||
"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 | ||||
changeset in the repository. "remote" means the name is derived from the | ||||
remote's path/URL. Defaults to "identity." | ||||
|
r39586 | |||
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. | ||||
|
r2597 | """ | ||
|
r4478 | |||
|
r32970 | if isinstance(source, bytes): | ||
r50640 | src_path = urlutil.get_clone_path_obj(ui, source) | |||
if src_path is None: | ||||
srcpeer = peer(ui, peeropts, b'') | ||||
origsource = source = b'' | ||||
branches = (None, branch or []) | ||||
else: | ||||
srcpeer = peer(ui, peeropts, src_path) | ||||
origsource = src_path.rawloc | ||||
branches = (src_path.branch, branch or []) | ||||
source = src_path.loc | ||||
|
r2719 | else: | ||
r50642 | if util.safehasattr(source, 'peer'): | |||
srcpeer = source.peer() # in case we were called with a localrepo | ||||
else: | ||||
srcpeer = source | ||||
branches = (None, branch or []) | ||||
r50640 | # XXX path: simply use the peer `path` object when this become available | |||
|
r17191 | origsource = source = srcpeer.url() | ||
|
r49326 | srclock = destlock = destwlock = cleandir = None | ||
|
r47419 | destpeer = None | ||
try: | ||||
revs, checkout = addbranchrevs(srcpeer, srcpeer, branches, revs) | ||||
|
r2719 | |||
|
r47419 | if dest is None: | ||
dest = defaultdest(source) | ||||
if dest: | ||||
ui.status(_(b"destination directory: %s\n") % dest) | ||||
else: | ||||
r50640 | dest_path = urlutil.get_clone_path_obj(ui, dest) | |||
if dest_path is not None: | ||||
dest = dest_path.rawloc | ||||
else: | ||||
dest = b'' | ||||
|
r2719 | |||
r47669 | dest = urlutil.urllocalpath(dest) | |||
source = urlutil.urllocalpath(source) | ||||
|
r2597 | |||
|
r47419 | if not dest: | ||
raise error.InputError(_(b"empty destination path is not valid")) | ||||
|
r21803 | |||
|
r47419 | destvfs = vfsmod.vfs(dest, expandpath=True) | ||
if destvfs.lexists(): | ||||
if not destvfs.isdir(): | ||||
raise error.InputError( | ||||
_(b"destination '%s' already exists") % dest | ||||
) | ||||
elif destvfs.listdir(): | ||||
raise error.InputError( | ||||
_(b"destination '%s' is not empty") % dest | ||||
) | ||||
|
r2597 | |||
|
r47419 | createopts = {} | ||
narrow = False | ||||
|
r39586 | |||
|
r47419 | if storeincludepats is not None: | ||
narrowspec.validatepatterns(storeincludepats) | ||||
narrow = True | ||||
if storeexcludepats is not None: | ||||
narrowspec.validatepatterns(storeexcludepats) | ||||
narrow = True | ||||
|
r39586 | |||
|
r47419 | if narrow: | ||
# Include everything by default if only exclusion patterns defined. | ||||
if storeexcludepats and not storeincludepats: | ||||
storeincludepats = {b'path:.'} | ||||
|
r39586 | |||
|
r47419 | createopts[b'narrowfiles'] = True | ||
|
r39586 | |||
|
r47419 | if depth: | ||
createopts[b'shallowfilestore'] = True | ||||
|
r40426 | |||
|
r47419 | if srcpeer.capable(b'lfs-serve'): | ||
# Repository creation honors the config if it disabled the extension, so | ||||
# we can't just announce that lfs will be enabled. This check avoids | ||||
# saying that lfs will be enabled, and then saying it's an unknown | ||||
# feature. The lfs creation option is set in either case so that a | ||||
# requirement is added. If the extension is explicitly disabled but the | ||||
# requirement is set, the clone aborts early, before transferring any | ||||
# data. | ||||
createopts[b'lfs'] = True | ||||
|
r40360 | |||
|
r47419 | if extensions.disabled_help(b'lfs'): | ||
ui.status( | ||||
_( | ||||
b'(remote is using large file support (lfs), but it is ' | ||||
b'explicitly disabled in the local configuration)\n' | ||||
) | ||||
|
r43346 | ) | ||
|
r47419 | else: | ||
ui.status( | ||||
_( | ||||
b'(remote is using large file support (lfs); lfs will ' | ||||
b'be enabled for this repository)\n' | ||||
) | ||||
|
r43346 | ) | ||
|
r40360 | |||
|
r47419 | shareopts = shareopts or {} | ||
sharepool = shareopts.get(b'pool') | ||||
sharenamemode = shareopts.get(b'mode') | ||||
if sharepool and islocal(dest): | ||||
sharepath = None | ||||
if sharenamemode == b'identity': | ||||
# Resolve the name from the initial changeset in the remote | ||||
# repository. This returns nullid when the remote is empty. It | ||||
# raises RepoLookupError if revision 0 is filtered or otherwise | ||||
# not available. If we fail to resolve, sharing is not enabled. | ||||
try: | ||||
with srcpeer.commandexecutor() as e: | ||||
rootnode = e.callcommand( | ||||
b'lookup', | ||||
{ | ||||
b'key': b'0', | ||||
}, | ||||
).result() | ||||
|
r37658 | |||
|
r47771 | if rootnode != sha1nodeconstants.nullid: | ||
|
r47419 | sharepath = os.path.join(sharepool, hex(rootnode)) | ||
else: | ||||
ui.status( | ||||
_( | ||||
b'(not using pooled storage: ' | ||||
b'remote appears to be empty)\n' | ||||
) | ||||
) | ||||
except error.RepoLookupError: | ||||
|
r43346 | ui.status( | ||
_( | ||||
|
r43347 | b'(not using pooled storage: ' | ||
|
r47419 | b'unable to resolve identity of remote)\n' | ||
|
r43346 | ) | ||
) | ||||
|
r47419 | elif sharenamemode == b'remote': | ||
sharepath = os.path.join( | ||||
sharepool, hex(hashutil.sha1(source).digest()) | ||||
) | ||||
else: | ||||
raise error.Abort( | ||||
_(b'unknown share naming mode: %s') % sharenamemode | ||||
|
r43346 | ) | ||
|
r47419 | |||
# TODO this is a somewhat arbitrary restriction. | ||||
if narrow: | ||||
ui.status( | ||||
_(b'(pooled storage not supported for narrow clones)\n') | ||||
) | ||||
sharepath = None | ||||
|
r25761 | |||
|
r47419 | if sharepath: | ||
return clonewithshare( | ||||
ui, | ||||
peeropts, | ||||
sharepath, | ||||
source, | ||||
srcpeer, | ||||
dest, | ||||
pull=pull, | ||||
rev=revs, | ||||
update=update, | ||||
stream=stream, | ||||
) | ||||
|
r39586 | |||
|
r47419 | srcrepo = srcpeer.local() | ||
|
r25761 | |||
|
r14377 | abspath = origsource | ||
if islocal(origsource): | ||||
r48426 | abspath = util.abspath(urlutil.urllocalpath(origsource)) | |||
|
r14377 | |||
|
r4915 | if islocal(dest): | ||
r48209 | if os.path.exists(dest): | |||
# only clean up directories we create ourselves | ||||
hgdir = os.path.realpath(os.path.join(dest, b".hg")) | ||||
cleandir = hgdir | ||||
else: | ||||
cleandir = dest | ||||
|
r2597 | |||
|
r4915 | copy = False | ||
|
r43346 | if ( | ||
srcrepo | ||||
and srcrepo.cancopy() | ||||
and islocal(dest) | ||||
and not phases.hassecret(srcrepo) | ||||
): | ||||
|
r37279 | copy = not pull and not revs | ||
|
r2597 | |||
|
r39586 | # TODO this is a somewhat arbitrary restriction. | ||
if narrow: | ||||
copy = False | ||||
|
r4915 | if copy: | ||
try: | ||||
# we use a lock here because if we race with commit, we | ||||
# can end up with extra data in the cloned revlogs that's | ||||
# not pointed to by changesets, thus causing verify to | ||||
# fail | ||||
|
r14463 | srclock = srcrepo.lock(wait=False) | ||
|
r7640 | except error.LockError: | ||
|
r4915 | copy = False | ||
|
r2597 | |||
|
r4915 | if copy: | ||
|
r43347 | srcrepo.hook(b'preoutgoing', throw=True, source=b'clone') | ||
|
r2597 | |||
r48235 | destrootpath = urlutil.urllocalpath(dest) | |||
dest_reqs = localrepo.clone_requirements(ui, createopts, srcrepo) | ||||
localrepo.createrepository( | ||||
ui, | ||||
destrootpath, | ||||
requirements=dest_reqs, | ||||
) | ||||
destrepo = localrepo.makelocalrepository(ui, destrootpath) | ||||
|
r49326 | |||
destwlock = destrepo.wlock() | ||||
r48240 | destlock = destrepo.lock() | |||
from . import streamclone # avoid cycle | ||||
r48235 | ||||
r48240 | streamclone.local_copy(srcrepo, destrepo) | |||
|
r17740 | |||
|
r4915 | # we need to re-init the repo after manually copying the data | ||
# into it | ||||
|
r17874 | destpeer = peer(srcrepo, peeropts, dest) | ||
|
r49326 | |||
# make the peer aware that is it already locked | ||||
# | ||||
# important: | ||||
# | ||||
# We still need to release that lock at the end of the function | ||||
destpeer.local()._lockref = weakref.ref(destlock) | ||||
destpeer.local()._wlockref = weakref.ref(destwlock) | ||||
# dirstate also needs to be copied because `_wlockref` has a reference | ||||
# to it: this dirstate is saved to disk when the wlock is released | ||||
destpeer.local().dirstate = destrepo.dirstate | ||||
|
r47771 | srcrepo.hook( | ||
b'outgoing', source=b'clone', node=srcrepo.nodeconstants.nullhex | ||||
) | ||||
|
r4915 | else: | ||
|
r5569 | try: | ||
|
r39586 | # only pass ui when no srcrepo | ||
|
r43346 | destpeer = peer( | ||
srcrepo or ui, | ||||
peeropts, | ||||
dest, | ||||
create=True, | ||||
createopts=createopts, | ||||
) | ||||
|
r50200 | except FileExistsError: | ||
cleandir = None | ||||
raise error.Abort(_(b"destination '%s' already exists") % dest) | ||||
|
r2597 | |||
|
r37279 | if revs: | ||
|
r43347 | if not srcpeer.capable(b'lookup'): | ||
|
r43346 | raise error.Abort( | ||
_( | ||||
|
r43347 | b"src repository does not support " | ||
b"revision lookup and so doesn't " | ||||
b"support clone by revision" | ||||
|
r43346 | ) | ||
) | ||||
|
r37658 | |||
# TODO this is batchable. | ||||
remoterevs = [] | ||||
for rev in revs: | ||||
with srcpeer.commandexecutor() as e: | ||||
|
r43346 | remoterevs.append( | ||
|
r46554 | e.callcommand( | ||
b'lookup', | ||||
{ | ||||
b'key': rev, | ||||
}, | ||||
).result() | ||||
|
r43346 | ) | ||
|
r37658 | revs = remoterevs | ||
|
r8417 | checkout = revs[0] | ||
|
r37279 | else: | ||
revs = None | ||||
|
r27165 | local = destpeer.local() | ||
if local: | ||||
|
r39591 | if narrow: | ||
|
r41072 | with local.wlock(), local.lock(): | ||
|
r39591 | local.setnarrowpats(storeincludepats, storeexcludepats) | ||
|
r41272 | narrowspec.copytoworkingcopy(local) | ||
|
r39591 | |||
r47669 | u = urlutil.url(abspath) | |||
|
r35581 | defaulturl = bytes(u) | ||
|
r43347 | local.ui.setconfig(b'paths', b'default', defaulturl, b'clone') | ||
|
r23545 | if not stream: | ||
if pull: | ||||
stream = False | ||||
else: | ||||
stream = None | ||||
|
r27165 | # internal config: ui.quietbookmarkmove | ||
|
r43347 | overrides = {(b'ui', b'quietbookmarkmove'): True} | ||
with local.ui.configoverride(overrides, b'clone'): | ||||
|
r43346 | exchange.pull( | ||
local, | ||||
srcpeer, | ||||
r49055 | heads=revs, | |||
|
r43346 | streamclonerequested=stream, | ||
includepats=storeincludepats, | ||||
excludepats=storeexcludepats, | ||||
depth=depth, | ||||
) | ||||
|
r17191 | elif srcrepo: | ||
|
r39586 | # TODO lift restriction once exchange.push() accepts narrow | ||
# push. | ||||
if narrow: | ||||
|
r43346 | raise error.Abort( | ||
_( | ||||
|
r43347 | b'narrow clone not available for ' | ||
b'remote destinations' | ||||
|
r43346 | ) | ||
) | ||||
|
r39586 | |||
|
r43346 | exchange.push( | ||
srcrepo, | ||||
destpeer, | ||||
revs=revs, | ||||
bookmarks=srcrepo._bookmarks.keys(), | ||||
) | ||||
|
r4915 | else: | ||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b"clone from remote to remote not supported") | ||
|
r43346 | ) | ||
|
r2597 | |||
|
r18441 | cleandir = None | ||
|
r2597 | |||
|
r17191 | destrepo = destpeer.local() | ||
if destrepo: | ||||
|
r43347 | template = uimod.samplehgrcs[b'cloned'] | ||
r47669 | u = urlutil.url(abspath) | |||
|
r15552 | u.passwd = None | ||
|
r33650 | defaulturl = bytes(u) | ||
|
r43347 | destrepo.vfs.write(b'hgrc', util.tonativeeol(template % defaulturl)) | ||
destrepo.ui.setconfig(b'paths', b'default', defaulturl, b'clone') | ||||
|
r8814 | |||
|
r43347 | if ui.configbool(b'experimental', b'remotenames'): | ||
|
r35348 | logexchange.pullremotenames(destrepo, srcpeer) | ||
|
r35332 | |||
|
r4915 | if update: | ||
|
r6526 | if update is not True: | ||
|
r37658 | with srcpeer.commandexecutor() as e: | ||
|
r43346 | checkout = e.callcommand( | ||
|
r46554 | b'lookup', | ||
{ | ||||
b'key': update, | ||||
}, | ||||
|
r43346 | ).result() | ||
|
r37658 | |||
|
r17867 | uprev = None | ||
|
r17882 | status = None | ||
|
r17867 | if checkout is not None: | ||
|
r38776 | # Some extensions (at least hg-git and hg-subversion) have | ||
# a peer.lookup() implementation that returns a name instead | ||||
# of a nodeid. We work around it here until we've figured | ||||
# out a better solution. | ||||
if len(checkout) == 20 and checkout in destrepo: | ||||
|
r37498 | uprev = checkout | ||
|
r38776 | elif scmutil.isrevsymbol(destrepo, checkout): | ||
uprev = scmutil.revsymbol(destrepo, checkout).node() | ||||
|
r37498 | else: | ||
|
r26354 | if update is not True: | ||
try: | ||||
uprev = destrepo.lookup(update) | ||||
except error.RepoLookupError: | ||||
pass | ||||
|
r17867 | if uprev is None: | ||
try: | ||||
|
r46814 | if destrepo._activebookmark: | ||
uprev = destrepo.lookup(destrepo._activebookmark) | ||||
update = destrepo._activebookmark | ||||
else: | ||||
uprev = destrepo._bookmarks[b'@'] | ||||
update = b'@' | ||||
|
r17882 | bn = destrepo[uprev].branch() | ||
|
r43347 | if bn == b'default': | ||
|
r46814 | status = _(b"updating to bookmark %s\n" % update) | ||
|
r17882 | else: | ||
|
r43346 | status = ( | ||
|
r46814 | _(b"updating to bookmark %s on branch %s\n") | ||
) % (update, bn) | ||||
|
r17867 | except KeyError: | ||
try: | ||||
|
r43347 | uprev = destrepo.branchtip(b'default') | ||
|
r17867 | except error.RepoLookupError: | ||
|
r43347 | uprev = destrepo.lookup(b'tip') | ||
|
r17882 | if not status: | ||
bn = destrepo[uprev].branch() | ||||
|
r43347 | status = _(b"updating to branch %s\n") % bn | ||
|
r17882 | destrepo.ui.status(status) | ||
|
r14463 | _update(destrepo, uprev) | ||
|
r17703 | if update in destrepo._bookmarks: | ||
|
r24945 | bookmarks.activate(destrepo, update) | ||
r47032 | if destlock is not None: | |||
release(destlock) | ||||
|
r49326 | if destwlock is not None: | ||
release(destlock) | ||||
r47032 | # here is a tiny windows were someone could end up writing the | |||
# repository before the cache are sure to be warm. This is "fine" | ||||
# as the only "bad" outcome would be some slowness. That potential | ||||
# slowness already affect reader. | ||||
with destrepo.lock(): | ||||
r48079 | destrepo.updatecaches(caches=repositorymod.CACHES_POST_CLONE) | |||
|
r4915 | finally: | ||
|
r49326 | release(srclock, destlock, destwlock) | ||
|
r18441 | if cleandir is not None: | ||
shutil.rmtree(cleandir, True) | ||||
|
r17191 | if srcpeer is not None: | ||
srcpeer.close() | ||||
|
r47419 | if destpeer and destpeer.local() is None: | ||
destpeer.close() | ||||
|
r19313 | return srcpeer, destpeer | ||
|
r2775 | |||
|
r43346 | |||
|
r27402 | def _showstats(repo, stats, quietempty=False): | ||
|
r37143 | if quietempty and stats.isempty(): | ||
|
r27402 | return | ||
|
r43346 | repo.ui.status( | ||
_( | ||||
|
r43347 | b"%d files updated, %d files merged, " | ||
b"%d files removed, %d files unresolved\n" | ||||
|
r43346 | ) | ||
% ( | ||||
stats.updatedcount, | ||||
stats.mergedcount, | ||||
stats.removedcount, | ||||
stats.unresolvedcount, | ||||
) | ||||
) | ||||
|
r3316 | |||
|
r31166 | def updaterepo(repo, node, overwrite, updatecheck=None): | ||
|
r17895 | """Update the working directory to node. | ||
When overwrite is set, changes are clobbered, merged else | ||||
returns stats (see pydoc mercurial.merge.applyupdates)""" | ||||
|
r46180 | repo.ui.deprecwarn( | ||
b'prefer merge.update() or merge.clean_update() over hg.updaterepo()', | ||||
b'5.7', | ||||
) | ||||
|
r46134 | return mergemod._update( | ||
|
r43346 | repo, | ||
node, | ||||
branchmerge=False, | ||||
force=overwrite, | ||||
|
r43347 | labels=[b'working copy', b'destination'], | ||
|
r43346 | updatecheck=updatecheck, | ||
) | ||||
|
r17895 | |||
|
r31166 | def update(repo, node, quietempty=False, updatecheck=None): | ||
"""update the working directory to node""" | ||||
|
r46151 | stats = mergemod.update(repo[node], updatecheck=updatecheck) | ||
|
r27404 | _showstats(repo, stats, quietempty) | ||
|
r37143 | if stats.unresolvedcount: | ||
|
r43347 | repo.ui.status(_(b"use 'hg resolve' to retry unresolved file merges\n")) | ||
|
r37143 | return stats.unresolvedcount > 0 | ||
|
r2775 | |||
|
r43346 | |||
|
r7546 | # naming conflict in clone() | ||
_update = update | ||||
|
r43346 | |||
|
r27403 | def clean(repo, node, show_stats=True, quietempty=False): | ||
|
r2808 | """forcibly switch the working directory to node, clobbering changes""" | ||
|
r46133 | stats = mergemod.clean_update(repo[node]) | ||
|
r44620 | assert stats.unresolvedcount == 0 | ||
|
r10282 | if show_stats: | ||
|
r27403 | _showstats(repo, stats, quietempty) | ||
r47495 | return False | |||
|
r2775 | |||
|
r43346 | |||
|
r28501 | # naming conflict in updatetotally() | ||
_clean = clean | ||||
|
r43346 | _VALID_UPDATECHECKS = { | ||
mergemod.UPDATECHECK_ABORT, | ||||
mergemod.UPDATECHECK_NONE, | ||||
mergemod.UPDATECHECK_LINEAR, | ||||
mergemod.UPDATECHECK_NO_CONFLICT, | ||||
|
r43241 | } | ||
|
r43346 | |||
|
r31166 | def updatetotally(ui, repo, checkout, brev, clean=False, updatecheck=None): | ||
|
r28501 | """Update the working directory with extra care for non-file components | ||
This takes care of non-file components below: | ||||
:bookmark: might be advanced or (in)activated | ||||
This takes arguments below: | ||||
:checkout: to which revision the working directory is updated | ||||
:brev: a name, which might be a bookmark to be activated after updating | ||||
:clean: whether changes in the working directory can be discarded | ||||
|
r31166 | :updatecheck: how to deal with a dirty working directory | ||
|
r43240 | Valid values for updatecheck are the UPDATECHECK_* constants | ||
defined in the merge module. Passing `None` will result in using the | ||||
configured default. | ||||
|
r31166 | |||
|
r43240 | * ABORT: abort if the working directory is dirty | ||
* NONE: don't check (merge working directory changes into destination) | ||||
* LINEAR: check that update is linear before merging working directory | ||||
|
r31166 | changes into destination | ||
|
r43240 | * NO_CONFLICT: check that the update does not result in file merges | ||
|
r28501 | |||
This returns whether conflict is detected at updating or not. | ||||
""" | ||||
|
r31166 | if updatecheck is None: | ||
|
r43347 | updatecheck = ui.config(b'commands', b'update.check') | ||
|
r43241 | if updatecheck not in _VALID_UPDATECHECKS: | ||
|
r31167 | # If not configured, or invalid value configured | ||
|
r43240 | updatecheck = mergemod.UPDATECHECK_LINEAR | ||
|
r43241 | if updatecheck not in _VALID_UPDATECHECKS: | ||
|
r43346 | raise ValueError( | ||
r'Invalid updatecheck value %r (can accept %r)' | ||||
% (updatecheck, _VALID_UPDATECHECKS) | ||||
) | ||||
|
r28503 | with repo.wlock(): | ||
|
r28501 | movemarkfrom = None | ||
warndest = False | ||||
if checkout is None: | ||||
|
r30962 | updata = destutil.destupdate(repo, clean=clean) | ||
|
r28501 | checkout, movemarkfrom, brev = updata | ||
warndest = True | ||||
if clean: | ||||
ret = _clean(repo, checkout) | ||||
else: | ||||
|
r43240 | if updatecheck == mergemod.UPDATECHECK_ABORT: | ||
|
r30963 | cmdutil.bailifchanged(repo, merge=False) | ||
|
r43240 | updatecheck = mergemod.UPDATECHECK_NONE | ||
|
r31166 | ret = _update(repo, checkout, updatecheck=updatecheck) | ||
|
r28501 | |||
if not ret and movemarkfrom: | ||||
|
r43347 | if movemarkfrom == repo[b'.'].node(): | ||
|
r43346 | pass # no-op update | ||
|
r43347 | elif bookmarks.update(repo, [movemarkfrom], repo[b'.'].node()): | ||
b = ui.label(repo._activebookmark, b'bookmarks.active') | ||||
ui.status(_(b"updating bookmark %s\n") % b) | ||||
|
r28501 | else: | ||
# this can happen with a non-linear update | ||||
|
r43347 | b = ui.label(repo._activebookmark, b'bookmarks') | ||
ui.status(_(b"(leaving bookmark %s)\n") % b) | ||||
|
r28501 | bookmarks.deactivate(repo) | ||
elif brev in repo._bookmarks: | ||||
if brev != repo._activebookmark: | ||||
|
r43347 | b = ui.label(brev, b'bookmarks.active') | ||
ui.status(_(b"(activating bookmark %s)\n") % b) | ||||
|
r28501 | bookmarks.activate(repo, brev) | ||
elif brev: | ||||
if repo._activebookmark: | ||||
|
r43347 | b = ui.label(repo._activebookmark, b'bookmarks') | ||
ui.status(_(b"(leaving bookmark %s)\n") % b) | ||||
|
r28501 | bookmarks.deactivate(repo) | ||
if warndest: | ||||
destutil.statusotherdests(ui, repo) | ||||
return ret | ||||
|
r43346 | |||
def merge( | ||||
|
r46554 | ctx, | ||
force=False, | ||||
remind=True, | ||||
labels=None, | ||||
|
r43346 | ): | ||
|
r13162 | """Branch merge with node, resolving changes. Return true if any | ||
unresolved conflicts.""" | ||||
|
r44916 | repo = ctx.repo() | ||
stats = mergemod.merge(ctx, force=force, labels=labels) | ||||
|
r3316 | _showstats(repo, stats) | ||
|
r37143 | if stats.unresolvedcount: | ||
|
r43346 | repo.ui.status( | ||
_( | ||||
|
r43347 | b"use 'hg resolve' to retry unresolved file merges " | ||
b"or 'hg merge --abort' to abandon\n" | ||||
|
r43346 | ) | ||
) | ||||
|
r42803 | elif remind: | ||
|
r43347 | repo.ui.status(_(b"(branch merge, don't forget to commit)\n")) | ||
|
r37143 | return stats.unresolvedcount > 0 | ||
|
r2808 | |||
|
r43346 | |||
|
r42810 | def abortmerge(ui, repo): | ||
|
r45383 | ms = mergestatemod.mergestate.read(repo) | ||
|
r42803 | if ms.active(): | ||
# there were conflicts | ||||
node = ms.localctx.hex() | ||||
else: | ||||
# there were no conficts, mergestate was not stored | ||||
|
r43347 | node = repo[b'.'].hex() | ||
|
r42803 | |||
|
r43387 | repo.ui.status(_(b"aborting the merge, updating back to %s\n") % node[:12]) | ||
|
r44743 | stats = mergemod.clean_update(repo[node]) | ||
|
r44636 | assert stats.unresolvedcount == 0 | ||
|
r42803 | _showstats(repo, stats) | ||
|
r43346 | |||
def _incoming( | ||||
r47712 | displaychlist, | |||
subreporecurse, | ||||
ui, | ||||
repo, | ||||
source, | ||||
opts, | ||||
buffered=False, | ||||
subpath=None, | ||||
|
r43346 | ): | ||
|
r12730 | """ | ||
Helper for incoming / gincoming. | ||||
displaychlist gets called with | ||||
(remoterepo, incomingchangesetlist, displayer) parameters, | ||||
and is supposed to contain only code that can't be unified. | ||||
""" | ||||
r49054 | srcs = urlutil.get_pull_paths(repo, ui, [source]) | |||
r47694 | srcs = list(srcs) | |||
if len(srcs) != 1: | ||||
|
r47768 | msg = _(b'for now, incoming supports only a single source, %d provided') | ||
r47694 | msg %= len(srcs) | |||
raise error.Abort(msg) | ||||
r49054 | path = srcs[0] | |||
r50613 | if subpath is None: | |||
peer_path = path | ||||
url = path.loc | ||||
else: | ||||
# XXX path: we are losing the `path` object here. Keeping it would be | ||||
# valuable. For example as a "variant" as we do for pushes. | ||||
r47712 | subpath = urlutil.url(subpath) | |||
if subpath.isabs(): | ||||
r50613 | peer_path = url = bytes(subpath) | |||
r47712 | else: | |||
r50613 | p = urlutil.url(path.loc) | |||
|
r49400 | if p.islocal(): | ||
normpath = os.path.normpath | ||||
else: | ||||
normpath = posixpath.normpath | ||||
p.path = normpath(b'%s/%s' % (p.path, subpath)) | ||||
r50613 | peer_path = url = bytes(p) | |||
other = peer(repo, opts, peer_path) | ||||
|
r47419 | cleanupfn = other.close | ||
try: | ||||
r50613 | ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(url)) | |||
branches = (path.branch, opts.get(b'branch', [])) | ||||
|
r47419 | revs, checkout = addbranchrevs(repo, other, branches, opts.get(b'rev')) | ||
|
r12730 | |||
|
r47419 | if revs: | ||
revs = [other.lookup(rev) for rev in revs] | ||||
other, chlist, cleanupfn = bundlerepo.getremotechanges( | ||||
|
r48987 | ui, repo, other, revs, opts.get(b"bundle"), opts.get(b"force") | ||
|
r47419 | ) | ||
|
r14161 | if not chlist: | ||
|
r43347 | ui.status(_(b"no changes found\n")) | ||
|
r14161 | return subreporecurse() | ||
|
r43347 | ui.pager(b'incoming') | ||
|
r43346 | displayer = logcmdutil.changesetdisplayer( | ||
ui, other, opts, buffered=buffered | ||||
) | ||||
|
r12730 | displaychlist(other, chlist, displayer) | ||
displayer.close() | ||||
finally: | ||||
|
r14161 | cleanupfn() | ||
|
r12730 | subreporecurse() | ||
|
r43346 | return 0 # exit code is zero since we found incoming changes | ||
|
r12730 | |||
r47712 | def incoming(ui, repo, source, opts, subpath=None): | |||
|
r12730 | def subreporecurse(): | ||
|
r12400 | ret = 1 | ||
|
r43347 | if opts.get(b'subrepos'): | ||
|
r12400 | ctx = repo[None] | ||
for subpath in sorted(ctx.substate): | ||||
sub = ctx.sub(subpath) | ||||
ret = min(ret, sub.incoming(ui, source, opts)) | ||||
return ret | ||||
|
r12730 | def display(other, chlist, displayer): | ||
|
r35906 | limit = logcmdutil.getlimit(opts) | ||
|
r43347 | if opts.get(b'newest_first'): | ||
|
r12729 | chlist.reverse() | ||
|
r12273 | count = 0 | ||
|
r12729 | for n in chlist: | ||
|
r12273 | if limit is not None and count >= limit: | ||
break | ||||
|
r47771 | parents = [ | ||
p for p in other.changelog.parents(n) if p != repo.nullid | ||||
] | ||||
|
r43347 | if opts.get(b'no_merges') and len(parents) == 2: | ||
|
r12273 | continue | ||
count += 1 | ||||
displayer.show(other[n]) | ||||
|
r43346 | |||
r47712 | return _incoming( | |||
display, subreporecurse, ui, repo, source, opts, subpath=subpath | ||||
) | ||||
|
r12273 | |||
|
r43346 | |||
r47693 | def _outgoing(ui, repo, dests, opts, subpath=None): | |||
out = set() | ||||
others = [] | ||||
for path in urlutil.get_push_paths(repo, ui, dests): | ||||
r50596 | dest = path.loc | |||
r47693 | if subpath is not None: | |||
subpath = urlutil.url(subpath) | ||||
if subpath.isabs(): | ||||
dest = bytes(subpath) | ||||
else: | ||||
p = urlutil.url(dest) | ||||
|
r49400 | if p.islocal(): | ||
normpath = os.path.normpath | ||||
else: | ||||
normpath = posixpath.normpath | ||||
p.path = normpath(b'%s/%s' % (p.path, subpath)) | ||||
r47693 | dest = bytes(p) | |||
branches = path.branch, opts.get(b'branch') or [] | ||||
r47692 | ||||
r47693 | ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(dest)) | |||
revs, checkout = addbranchrevs(repo, repo, branches, opts.get(b'rev')) | ||||
if revs: | ||||
|
r48928 | revs = [repo[rev].node() for rev in logcmdutil.revrange(repo, revs)] | ||
|
r12735 | |||
r47693 | other = peer(repo, opts, dest) | |||
try: | ||||
outgoing = discovery.findcommonoutgoing( | ||||
repo, other, revs, force=opts.get(b'force') | ||||
) | ||||
o = outgoing.missing | ||||
out.update(o) | ||||
if not o: | ||||
scmutil.nochangesfound(repo.ui, repo, outgoing.excluded) | ||||
others.append(other) | ||||
except: # re-raises | ||||
other.close() | ||||
raise | ||||
# make sure this is ordered by revision number | ||||
outgoing_revs = list(out) | ||||
cl = repo.changelog | ||||
outgoing_revs.sort(key=cl.rev) | ||||
return outgoing_revs, others | ||||
|
r12735 | |||
|
r43346 | |||
r47693 | def _outgoing_recurse(ui, repo, dests, opts): | |||
r47675 | ret = 1 | |||
if opts.get(b'subrepos'): | ||||
ctx = repo[None] | ||||
for subpath in sorted(ctx.substate): | ||||
sub = ctx.sub(subpath) | ||||
r47693 | ret = min(ret, sub.outgoing(ui, dests, opts)) | |||
r47675 | return ret | |||
r47676 | def _outgoing_filter(repo, revs, opts): | |||
"""apply revision filtering/ordering option for outgoing""" | ||||
limit = logcmdutil.getlimit(opts) | ||||
no_merges = opts.get(b'no_merges') | ||||
if opts.get(b'newest_first'): | ||||
revs.reverse() | ||||
if limit is None and not no_merges: | ||||
for r in revs: | ||||
yield r | ||||
return | ||||
count = 0 | ||||
cl = repo.changelog | ||||
for n in revs: | ||||
if limit is not None and count >= limit: | ||||
break | ||||
|
r47771 | parents = [p for p in cl.parents(n) if p != repo.nullid] | ||
r47676 | if no_merges and len(parents) == 2: | |||
continue | ||||
count += 1 | ||||
yield n | ||||
r47693 | def outgoing(ui, repo, dests, opts, subpath=None): | |||
r47677 | if opts.get(b'graph'): | |||
logcmdutil.checkunsupportedgraphflags([], opts) | ||||
r47693 | o, others = _outgoing(ui, repo, dests, opts, subpath=subpath) | |||
r47674 | ret = 1 | |||
|
r47419 | try: | ||
r47674 | if o: | |||
ret = 0 | ||||
|
r12400 | |||
r47677 | if opts.get(b'graph'): | |||
revdag = logcmdutil.graphrevs(repo, o, opts) | ||||
ui.pager(b'outgoing') | ||||
displayer = logcmdutil.changesetdisplayer( | ||||
ui, repo, opts, buffered=True | ||||
) | ||||
logcmdutil.displaygraph( | ||||
ui, repo, revdag, displayer, graphmod.asciiedges | ||||
) | ||||
else: | ||||
ui.pager(b'outgoing') | ||||
displayer = logcmdutil.changesetdisplayer(ui, repo, opts) | ||||
for n in _outgoing_filter(repo, o, opts): | ||||
displayer.show(repo[n]) | ||||
displayer.close() | ||||
r47693 | for oth in others: | |||
cmdutil.outgoinghooks(ui, repo, oth, opts, o) | ||||
ret = min(ret, _outgoing_recurse(ui, repo, dests, opts)) | ||||
r47674 | return ret # exit code is zero since we found outgoing changes | |||
|
r47419 | finally: | ||
r47693 | for oth in others: | |||
oth.close() | ||||
|
r43346 | |||
|
r12271 | |||
r42331 | def verify(repo, level=None): | |||
|
r2778 | """verify the consistency of a repository""" | ||
r42331 | ret = verifymod.verify(repo, level=level) | |||
|
r25591 | |||
# Broken subrepo references in hidden csets don't seem worth worrying about, | ||||
# since they can't be pushed/pulled, and --hidden can be used if they are a | ||||
# concern. | ||||
# pathto() is needed for -R case | ||||
|
r43346 | revs = repo.revs( | ||
|
r43347 | b"filelog(%s)", util.pathto(repo.root, repo.getcwd(), b'.hgsubstate') | ||
|
r43346 | ) | ||
|
r25591 | |||
if revs: | ||||
|
r43347 | repo.ui.status(_(b'checking subrepo links\n')) | ||
|
r25591 | for rev in revs: | ||
ctx = repo[rev] | ||||
try: | ||||
for subpath in ctx.substate: | ||||
|
r29021 | try: | ||
|
r43346 | ret = ( | ||
ctx.sub(subpath, allowcreate=False).verify() or ret | ||||
) | ||||
|
r29021 | except error.RepoError as e: | ||
|
r43347 | repo.ui.warn(b'%d: %s\n' % (rev, e)) | ||
|
r25591 | except Exception: | ||
|
r43346 | repo.ui.warn( | ||
|
r43347 | _(b'.hgsubstate is corrupt in revision %s\n') | ||
|
r46729 | % short(ctx.node()) | ||
|
r43346 | ) | ||
|
r25591 | |||
return ret | ||||
|
r11273 | |||
|
r43346 | |||
|
r11273 | def remoteui(src, opts): | ||
|
r44226 | """build a remote ui from ui or repo and opts""" | ||
|
r43347 | if util.safehasattr(src, b'baseui'): # looks like a repository | ||
|
r43346 | dst = src.baseui.copy() # drop repo-specific config | ||
src = src.ui # copy target options from repo | ||||
else: # assume it's a global ui object | ||||
dst = src.copy() # keep all global options | ||||
|
r11273 | |||
# copy ssh-specific options | ||||
|
r43347 | for o in b'ssh', b'remotecmd': | ||
v = opts.get(o) or src.config(b'ui', o) | ||||
|
r11273 | if v: | ||
|
r43347 | dst.setconfig(b"ui", o, v, b'copied') | ||
|
r11273 | |||
# copy bundle-specific options | ||||
|
r43347 | r = src.config(b'bundle', b'mainreporoot') | ||
|
r11273 | if r: | ||
|
r43347 | dst.setconfig(b'bundle', b'mainreporoot', r, b'copied') | ||
|
r11273 | |||
|
r13192 | # copy selected local settings to the remote ui | ||
|
r43347 | for sect in (b'auth', b'hostfingerprints', b'hostsecurity', b'http_proxy'): | ||
|
r11273 | for key, val in src.configitems(sect): | ||
|
r43347 | dst.setconfig(sect, key, val, b'copied') | ||
v = src.config(b'web', b'cacerts') | ||||
|
r29594 | if v: | ||
|
r43347 | dst.setconfig(b'web', b'cacerts', util.expandpath(v), b'copied') | ||
|
r11273 | |||
return dst | ||||
|
r26219 | |||
|
r43346 | |||
|
r26219 | # Files of interest | ||
# Used to check if the repository has changed looking at mtime and size of | ||||
|
r26781 | # these files. | ||
|
r43346 | foi = [ | ||
|
r43347 | (b'spath', b'00changelog.i'), | ||
(b'spath', b'phaseroots'), # ! phase can change content at the same size | ||||
(b'spath', b'obsstore'), | ||||
(b'path', b'bookmarks'), # ! bookmark can change content at the same size | ||||
|
r43346 | ] | ||
|
r26219 | |||
|
r49801 | class cachedlocalrepo: | ||
|
r26219 | """Holds a localrepository that can be cached and reused.""" | ||
def __init__(self, repo): | ||||
"""Create a new cached repo from an existing repo. | ||||
We assume the passed in repo was recently created. If the | ||||
repo has changed between when it was created and when it was | ||||
turned into a cache, it may not refresh properly. | ||||
""" | ||||
assert isinstance(repo, localrepo.localrepository) | ||||
self._repo = repo | ||||
self._state, self.mtime = self._repostate() | ||||
|
r28119 | self._filtername = repo.filtername | ||
|
r26219 | |||
def fetch(self): | ||||
"""Refresh (if necessary) and return a repository. | ||||
If the cached instance is out of date, it will be recreated | ||||
automatically and returned. | ||||
Returns a tuple of the repo and a boolean indicating whether a new | ||||
repo instance was created. | ||||
""" | ||||
# We compare the mtimes and sizes of some well-known files to | ||||
# determine if the repo changed. This is not precise, as mtimes | ||||
# are susceptible to clock skew and imprecise filesystems and | ||||
# file content can change while maintaining the same size. | ||||
state, mtime = self._repostate() | ||||
if state == self._state: | ||||
return self._repo, False | ||||
|
r28119 | repo = repository(self._repo.baseui, self._repo.url()) | ||
if self._filtername: | ||||
self._repo = repo.filtered(self._filtername) | ||||
else: | ||||
self._repo = repo.unfiltered() | ||||
|
r26219 | self._state = state | ||
self.mtime = mtime | ||||
return self._repo, True | ||||
def _repostate(self): | ||||
state = [] | ||||
maxmtime = -1 | ||||
for attr, fname in foi: | ||||
prefix = getattr(self._repo, attr) | ||||
p = os.path.join(prefix, fname) | ||||
try: | ||||
st = os.stat(p) | ||||
except OSError: | ||||
st = os.stat(prefix) | ||||
|
r36799 | state.append((st[stat.ST_MTIME], st.st_size)) | ||
maxmtime = max(maxmtime, st[stat.ST_MTIME]) | ||||
|
r26219 | |||
return tuple(state), maxmtime | ||||
def copy(self): | ||||
|
r26240 | """Obtain a copy of this class instance. | ||
A new localrepository instance is obtained. The new instance should be | ||||
completely independent of the original. | ||||
""" | ||||
repo = repository(self._repo.baseui, self._repo.origroot) | ||||
|
r28119 | if self._filtername: | ||
repo = repo.filtered(self._filtername) | ||||
else: | ||||
repo = repo.unfiltered() | ||||
|
r26240 | c = cachedlocalrepo(repo) | ||
|
r26219 | c._state = self._state | ||
c.mtime = self.mtime | ||||
return c | ||||