hg.py
1143 lines
| 39.6 KiB
| text/x-python
|
PythonLexer
/ mercurial / hg.py
|
r0 | # hg.py - repository classes for mercurial | ||
# | ||||
|
r4635 | # Copyright 2005-2007 Matt Mackall <mpm@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 | from __future__ import absolute_import | ||
import errno | ||||
|
r29341 | import hashlib | ||
|
r25939 | import os | ||
import shutil | ||||
|
r36799 | import stat | ||
|
r25939 | |||
from .i18n import _ | ||||
|
r35722 | from .node import ( | ||
nullid, | ||||
) | ||||
|
r22837 | |||
|
r25939 | from . import ( | ||
bookmarks, | ||||
bundlerepo, | ||||
|
r35784 | cacheutil, | ||
|
r25939 | cmdutil, | ||
|
r28501 | destutil, | ||
|
r25939 | discovery, | ||
error, | ||||
exchange, | ||||
extensions, | ||||
httppeer, | ||||
localrepo, | ||||
lock, | ||||
|
r35906 | logcmdutil, | ||
|
r35348 | logexchange, | ||
|
r25939 | merge as mergemod, | ||
node, | ||||
phases, | ||||
scmutil, | ||||
sshpeer, | ||||
statichttprepo, | ||||
ui as uimod, | ||||
unionrepo, | ||||
url, | ||||
util, | ||||
verify as verifymod, | ||||
|
r31218 | vfs as vfsmod, | ||
|
r25939 | ) | ||
|
r37102 | from .utils import ( | ||
stringutil, | ||||
) | ||||
|
r25939 | release = lock.release | ||
|
r0 | |||
|
r29424 | # shared features | ||
sharedbookmarks = 'bookmarks' | ||||
|
r2740 | def _local(path): | ||
|
r14825 | path = util.expandpath(util.urllocalpath(path)) | ||
|
r11154 | return (os.path.isfile(path) and bundlerepo or localrepo) | ||
|
r2469 | |||
|
r17191 | def addbranchrevs(lrepo, other, branches, revs): | ||
peer = other.peer() # a courtesy to callers using a localrepo for other | ||||
|
r11322 | hashbranch, branches = branches | ||
if not hashbranch and not branches: | ||||
|
r22818 | x = revs or None | ||
if util.safehasattr(revs, 'first'): | ||||
|
r27637 | y = revs.first() | ||
|
r22818 | elif revs: | ||
y = revs[0] | ||||
else: | ||||
y = None | ||||
return x, y | ||||
|
r24306 | if revs: | ||
revs = list(revs) | ||||
else: | ||||
revs = [] | ||||
|
r17191 | if not peer.capable('branchmap'): | ||
|
r11322 | if branches: | ||
|
r26587 | raise error.Abort(_("remote branch lookup not supported")) | ||
|
r11322 | revs.append(hashbranch) | ||
|
r10380 | return revs, revs[0] | ||
|
r17191 | branchmap = peer.branchmap() | ||
|
r11322 | |||
|
r13047 | def primary(branch): | ||
if branch == '.': | ||||
|
r17191 | if not lrepo: | ||
|
r26587 | raise error.Abort(_("dirstate branch not accessible")) | ||
|
r13047 | branch = lrepo.dirstate.branch() | ||
if branch in branchmap: | ||||
revs.extend(node.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): | ||
|
r11322 | raise error.RepoLookupError(_("unknown branch '%s'") % branch) | ||
if hashbranch: | ||||
|
r13047 | if not primary(hashbranch): | ||
|
r11322 | revs.append(hashbranch) | ||
|
r10365 | return revs, revs[0] | ||
|
r13824 | def parseurl(path, branches=None): | ||
|
r11322 | '''parse url#branch, returning (url, (branch, branches))''' | ||
|
r5177 | |||
|
r14076 | u = util.url(path) | ||
|
r13897 | branch = None | ||
if u.fragment: | ||||
branch = u.fragment | ||||
u.fragment = None | ||||
|
r31841 | return bytes(u), (branch, branches or []) | ||
|
r5177 | |||
|
r14606 | schemes = { | ||
|
r14568 | 'bundle': bundlerepo, | ||
|
r18944 | 'union': unionrepo, | ||
|
r14568 | 'file': _local, | ||
|
r17192 | 'http': httppeer, | ||
'https': httppeer, | ||||
'ssh': sshpeer, | ||||
|
r14568 | 'static-http': statichttprepo, | ||
} | ||||
def _peerlookup(path): | ||||
u = util.url(path) | ||||
scheme = u.scheme or 'file' | ||||
|
r14606 | thing = schemes.get(scheme) or schemes['file'] | ||
|
r14568 | try: | ||
return thing(path) | ||||
except TypeError: | ||||
|
r25365 | # we can't test callable(thing) because 'thing' can be an unloaded | ||
# module that implements __call__ | ||||
if not util.safehasattr(thing, 'instance'): | ||||
raise | ||||
|
r14568 | return thing | ||
|
r14605 | def islocal(repo): | ||
|
r20355 | '''return true if repo (or path pointing to repo) is local''' | ||
|
r33018 | if isinstance(repo, bytes): | ||
|
r14605 | try: | ||
return _peerlookup(repo).islocal(repo) | ||||
except AttributeError: | ||||
return False | ||||
return repo.local() | ||||
|
r17887 | def openpath(ui, path): | ||
'''open path with open if local, url.open if remote''' | ||||
|
r20354 | pathurl = util.url(path, parsequery=False, parsefragment=False) | ||
if pathurl.islocal(): | ||||
return util.posixfile(pathurl.localpath(), 'rb') | ||||
|
r17887 | else: | ||
return url.open(ui, path) | ||||
|
r20858 | # a list of (ui, repo) functions called for wire peer initialization | ||
wirepeersetupfuncs = [] | ||||
|
r32379 | def _peerorrepo(ui, path, create=False, presetupfuncs=None): | ||
|
r14605 | """return a repository object for the specified path""" | ||
|
r17191 | obj = _peerlookup(path).instance(ui, path, create) | ||
ui = getattr(obj, "ui", ui) | ||||
|
r32379 | for f in presetupfuncs or []: | ||
f(ui, obj) | ||||
|
r19777 | for name, module in extensions.extensions(ui): | ||
|
r14605 | hook = getattr(module, 'reposetup', None) | ||
if hook: | ||||
|
r17191 | hook(ui, obj) | ||
|
r20858 | if not obj.local(): | ||
for f in wirepeersetupfuncs: | ||||
f(ui, obj) | ||||
|
r17191 | return obj | ||
|
r32379 | def repository(ui, path='', create=False, presetupfuncs=None): | ||
|
r17191 | """return a repository object for the specified path""" | ||
|
r32379 | peer = _peerorrepo(ui, path, create, presetupfuncs=presetupfuncs) | ||
|
r17191 | repo = peer.local() | ||
if not repo: | ||||
|
r26587 | raise error.Abort(_("repository '%s' is not local") % | ||
|
r17191 | (path or peer.url())) | ||
|
r18382 | return repo.filtered('visible') | ||
|
r14605 | |||
|
r14839 | def peer(uiorrepo, opts, path, create=False): | ||
|
r14554 | '''return a repository peer for the specified path''' | ||
|
r14839 | rui = remoteui(uiorrepo, opts) | ||
|
r17191 | return _peerorrepo(rui, path, create).peer() | ||
|
r14554 | |||
|
r2719 | def defaultdest(source): | ||
|
r20799 | '''return default destination of clone if none is given | ||
|
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' | ||
''' | ||||
|
r20800 | path = util.url(source).path | ||
if not path: | ||||
return '' | ||||
return os.path.basename(os.path.normpath(path)) | ||||
|
r2774 | |||
|
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 | ||||
if util.safehasattr(repo, 'srcrepo') and repo.srcrepo: | ||||
return repo.srcrepo | ||||
# the sharedpath always ends in the .hg; we want the path to the repo | ||||
source = repo.vfs.split(repo.sharedpath)[0] | ||||
srcurl, branches = parseurl(source) | ||||
srcrepo = repository(repo.ui, srcurl) | ||||
repo.srcrepo = srcrepo | ||||
return srcrepo | ||||
|
r31133 | def share(ui, source, dest=None, update=True, bookmarks=True, defaultpath=None, | ||
relative=False): | ||||
|
r8800 | '''create a shared repository''' | ||
if not islocal(source): | ||||
|
r26587 | raise error.Abort(_('can only share local repositories')) | ||
|
r8800 | |||
|
r8807 | if not dest: | ||
|
r10099 | dest = defaultdest(source) | ||
|
r9344 | else: | ||
dest = ui.expandpath(dest) | ||||
|
r8807 | |||
|
r36066 | if isinstance(source, bytes): | ||
|
r8800 | origsource = ui.expandpath(source) | ||
|
r10365 | source, branches = parseurl(origsource) | ||
|
r8800 | srcrepo = repository(ui, source) | ||
|
r10365 | rev, checkout = addbranchrevs(srcrepo, srcrepo, branches, None) | ||
|
r8800 | else: | ||
|
r17191 | srcrepo = source.local() | ||
|
r8800 | origsource = source = srcrepo.url() | ||
checkout = None | ||||
sharedpath = srcrepo.sharedpath # if our source is already sharing | ||||
|
r31218 | destwvfs = vfsmod.vfs(dest, realpath=True) | ||
destvfs = vfsmod.vfs(os.path.join(destwvfs.base, '.hg'), realpath=True) | ||||
|
r8800 | |||
|
r21801 | if destvfs.lexists(): | ||
|
r26587 | raise error.Abort(_('destination already exists')) | ||
|
r8800 | |||
|
r21800 | if not destwvfs.isdir(): | ||
destwvfs.mkdir() | ||||
|
r21801 | destvfs.makedir() | ||
|
r8800 | |||
requirements = '' | ||||
try: | ||||
|
r23877 | requirements = srcrepo.vfs.read('requires') | ||
|
r25660 | except IOError as inst: | ||
|
r8800 | if inst.errno != errno.ENOENT: | ||
raise | ||||
|
r31133 | if relative: | ||
try: | ||||
sharedpath = os.path.relpath(sharedpath, destvfs.base) | ||||
requirements += 'relshared\n' | ||||
|
r34980 | except (IOError, ValueError) as e: | ||
# ValueError is raised on Windows if the drive letters differ on | ||||
# each path | ||||
|
r31133 | raise error.Abort(_('cannot calculate relative path'), | ||
|
r37102 | hint=stringutil.forcebytestr(e)) | ||
|
r31133 | else: | ||
requirements += 'shared\n' | ||||
|
r21802 | destvfs.write('requires', requirements) | ||
destvfs.write('sharedpath', sharedpath) | ||||
|
r8800 | |||
|
r21800 | r = repository(ui, destwvfs.base) | ||
|
r30041 | postshare(srcrepo, r, bookmarks=bookmarks, defaultpath=defaultpath) | ||
|
r28632 | _postshareupdate(r, update, checkout=checkout) | ||
|
r34816 | return r | ||
|
r8800 | |||
|
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. | ||||
""" | ||||
destlock = lock = None | ||||
lock = repo.lock() | ||||
try: | ||||
# 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) | ||||
sharefile = repo.vfs.join('sharedpath') | ||||
util.rename(sharefile, sharefile + '.old') | ||||
repo.requirements.discard('shared') | ||||
repo.requirements.discard('relshared') | ||||
repo._writerequirements() | ||||
finally: | ||||
destlock and destlock.release() | ||||
lock and lock.release() | ||||
# update store, spath, svfs and sjoin of repo | ||||
repo.unfiltered().__init__(repo.baseui, repo.root) | ||||
|
r34880 | # TODO: figure out how to access subrepos that exist, but were previously | ||
# removed from .hgsub | ||||
c = repo['.'] | ||||
subs = c.substate | ||||
for s in sorted(subs): | ||||
c.sub(s).unshare() | ||||
|
r30041 | def postshare(sourcerepo, destrepo, bookmarks=True, 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. | ||||
""" | ||||
|
r30041 | default = defaultpath or sourcerepo.ui.config('paths', 'default') | ||
|
r27354 | if default: | ||
|
r35640 | template = ('[paths]\n' | ||
'default = %s\n') | ||||
destrepo.vfs.write('hgrc', util.tonativeeol(template % default)) | ||||
|
r27354 | |||
|
r29753 | with destrepo.wlock(): | ||
if bookmarks: | ||||
|
r35637 | destrepo.vfs.write('shared', sharedbookmarks + '\n') | ||
|
r23614 | |||
|
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 | ||||
repo.ui.status(_("updating working directory\n")) | ||||
if update is not True: | ||||
checkout = update | ||||
for test in (checkout, 'default', 'tip'): | ||||
if test is None: | ||||
continue | ||||
try: | ||||
uprev = repo.lookup(test) | ||||
break | ||||
except error.RepoLookupError: | ||||
continue | ||||
_update(repo, uprev) | ||||
|
r15078 | def copystore(ui, srcrepo, destpath): | ||
'''copy files from store of srcrepo in destpath | ||||
returns destlock | ||||
''' | ||||
destlock = None | ||||
try: | ||||
hardlink = None | ||||
num = 0 | ||||
|
r24440 | closetopic = [None] | ||
def prog(topic, pos): | ||||
if pos is None: | ||||
closetopic[0] = topic | ||||
else: | ||||
ui.progress(topic, pos + num) | ||||
|
r25624 | srcpublishing = srcrepo.publishing() | ||
|
r31218 | srcvfs = vfsmod.vfs(srcrepo.sharedpath) | ||
dstvfs = vfsmod.vfs(destpath) | ||||
|
r15078 | for f in srcrepo.store.copylist(): | ||
|
r15741 | if srcpublishing and f.endswith('phaseroots'): | ||
continue | ||||
|
r20089 | dstbase = os.path.dirname(f) | ||
if dstbase and not dstvfs.exists(dstbase): | ||||
dstvfs.mkdir(dstbase) | ||||
if srcvfs.exists(f): | ||||
if f.endswith('data'): | ||||
|
r20825 | # 'dstbase' may be empty (e.g. revlog format 0) | ||
lockfile = os.path.join(dstbase, "lock") | ||||
|
r15078 | # lock to avoid premature writing to the target | ||
|
r20825 | destlock = lock.lock(dstvfs, lockfile) | ||
|
r20089 | hardlink, n = util.copyfiles(srcvfs.join(f), dstvfs.join(f), | ||
|
r24440 | hardlink, progress=prog) | ||
|
r15078 | num += n | ||
if hardlink: | ||||
ui.debug("linked %d files\n" % num) | ||||
|
r24440 | if closetopic[0]: | ||
ui.progress(closetopic[0], None) | ||||
|
r15078 | else: | ||
ui.debug("copied %d files\n" % num) | ||||
|
r24440 | if closetopic[0]: | ||
ui.progress(closetopic[0], None) | ||||
|
r15078 | return destlock | ||
|
r16705 | except: # re-raises | ||
|
r15078 | release(destlock) | ||
raise | ||||
|
r25761 | def clonewithshare(ui, peeropts, sharepath, source, srcpeer, dest, pull=False, | ||
rev=None, update=True, stream=False): | ||||
"""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: | ||||
if not srcpeer.capable('lookup'): | ||||
|
r26587 | raise error.Abort(_("src repository does not support " | ||
|
r25761 | "revision lookup and so doesn't " | ||
"support clone by revision")) | ||||
revs = [srcpeer.lookup(r) for r in rev] | ||||
|
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) | ||||
except OSError as e: | ||||
if e.errno != errno.EEXIST: | ||||
raise | ||||
|
r31218 | poolvfs = vfsmod.vfs(pooldir) | ||
|
r25761 | basename = os.path.basename(sharepath) | ||
|
r28289 | with lock.lock(poolvfs, '%s.lock' % basename): | ||
if os.path.exists(sharepath): | ||||
ui.status(_('(sharing from existing pooled repository %s)\n') % | ||||
basename) | ||||
else: | ||||
ui.status(_('(sharing from new pooled repository %s)\n') % basename) | ||||
# Always use pull mode because hardlinks in share mode don't work | ||||
# well. Never update because working copies aren't necessary in | ||||
# share mode. | ||||
clone(ui, peeropts, source, dest=sharepath, pull=True, | ||||
|
r37279 | revs=rev, update=False, stream=stream) | ||
|
r25761 | |||
|
r30041 | # Resolve the value to put in [paths] section for the source. | ||
if islocal(source): | ||||
defaultpath = os.path.abspath(util.urllocalpath(source)) | ||||
else: | ||||
defaultpath = source | ||||
|
r25761 | sharerepo = repository(ui, path=sharepath) | ||
|
r30041 | 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. | ||||
destrepo = repository(ui, path=dest) | ||||
exchange.pull(destrepo, srcpeer, heads=revs) | ||||
|
r28632 | _postshareupdate(destrepo, update) | ||
|
r25761 | return srcpeer, peer(ui, peeropts, dest) | ||
r32492 | # Recomputing branch cache might be slow on big repos, | |||
# so just copy it | ||||
def _copycache(srcrepo, dstcachedir, fname): | ||||
"""copy a cache from srcrepo to destcachedir (if it exists)""" | ||||
srcbranchcache = srcrepo.vfs.join('cache/%s' % fname) | ||||
dstbranchcache = os.path.join(dstcachedir, fname) | ||||
if os.path.exists(srcbranchcache): | ||||
if not os.path.exists(dstcachedir): | ||||
os.mkdir(dstcachedir) | ||||
util.copyfile(srcbranchcache, dstbranchcache) | ||||
|
r37279 | def clone(ui, peeropts, source, dest=None, pull=False, revs=None, | ||
|
r25761 | update=True, stream=False, branch=None, shareopts=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." | ||||
|
r2597 | """ | ||
|
r4478 | |||
|
r32970 | if isinstance(source, bytes): | ||
|
r6089 | origsource = ui.expandpath(source) | ||
|
r37278 | source, branches = parseurl(origsource, branch) | ||
|
r17191 | srcpeer = peer(ui, peeropts, source) | ||
|
r2719 | else: | ||
|
r17191 | srcpeer = source.peer() # in case we were called with a localrepo | ||
|
r37278 | branches = (None, branch or []) | ||
|
r17191 | origsource = source = srcpeer.url() | ||
|
r37279 | revs, checkout = addbranchrevs(srcpeer, srcpeer, branches, revs) | ||
|
r2719 | |||
|
r2597 | if dest is None: | ||
|
r2719 | dest = defaultdest(source) | ||
|
r20800 | if dest: | ||
ui.status(_("destination directory: %s\n") % dest) | ||||
|
r9344 | else: | ||
dest = ui.expandpath(dest) | ||||
|
r2719 | |||
|
r14825 | dest = util.urllocalpath(dest) | ||
source = util.urllocalpath(source) | ||||
|
r2597 | |||
|
r17159 | if not dest: | ||
|
r26587 | raise error.Abort(_("empty destination path is not valid")) | ||
|
r21803 | |||
|
r31218 | destvfs = vfsmod.vfs(dest, expandpath=True) | ||
|
r21803 | if destvfs.lexists(): | ||
if not destvfs.isdir(): | ||||
|
r26587 | raise error.Abort(_("destination '%s' already exists") % dest) | ||
|
r21804 | elif destvfs.listdir(): | ||
|
r26587 | raise error.Abort(_("destination '%s' is not empty") % dest) | ||
|
r2597 | |||
|
r25761 | shareopts = shareopts or {} | ||
sharepool = shareopts.get('pool') | ||||
sharenamemode = shareopts.get('mode') | ||||
|
r26026 | if sharepool and islocal(dest): | ||
|
r25761 | sharepath = None | ||
if sharenamemode == '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: | ||||
rootnode = srcpeer.lookup('0') | ||||
if rootnode != node.nullid: | ||||
sharepath = os.path.join(sharepool, node.hex(rootnode)) | ||||
else: | ||||
ui.status(_('(not using pooled storage: ' | ||||
'remote appears to be empty)\n')) | ||||
except error.RepoLookupError: | ||||
ui.status(_('(not using pooled storage: ' | ||||
'unable to resolve identity of remote)\n')) | ||||
elif sharenamemode == 'remote': | ||||
|
r29341 | sharepath = os.path.join( | ||
|
r35600 | sharepool, node.hex(hashlib.sha1(source).digest())) | ||
|
r25761 | else: | ||
|
r29389 | raise error.Abort(_('unknown share naming mode: %s') % | ||
sharenamemode) | ||||
|
r25761 | |||
if sharepath: | ||||
return clonewithshare(ui, peeropts, sharepath, source, srcpeer, | ||||
|
r37279 | dest, pull=pull, rev=revs, update=update, | ||
|
r25761 | stream=stream) | ||
|
r18441 | srclock = destlock = cleandir = None | ||
|
r17191 | srcrepo = srcpeer.local() | ||
|
r4915 | try: | ||
|
r14377 | abspath = origsource | ||
if islocal(origsource): | ||||
|
r14825 | abspath = os.path.abspath(util.urllocalpath(origsource)) | ||
|
r14377 | |||
|
r4915 | if islocal(dest): | ||
|
r18441 | cleandir = dest | ||
|
r2597 | |||
|
r4915 | copy = False | ||
|
r17194 | if (srcrepo and srcrepo.cancopy() and islocal(dest) | ||
|
r17671 | and not phases.hassecret(srcrepo)): | ||
|
r37279 | copy = not pull and not revs | ||
|
r2597 | |||
|
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: | ||
|
r14463 | srcrepo.hook('preoutgoing', throw=True, source='clone') | ||
|
r15381 | hgdir = os.path.realpath(os.path.join(dest, ".hg")) | ||
|
r4915 | if not os.path.exists(dest): | ||
os.mkdir(dest) | ||||
|
r7935 | else: | ||
# only clean up directories we create ourselves | ||||
|
r18441 | cleandir = hgdir | ||
|
r5569 | try: | ||
|
r14463 | destpath = hgdir | ||
util.makedir(destpath, notindexed=True) | ||||
|
r25660 | except OSError as inst: | ||
|
r5569 | if inst.errno == errno.EEXIST: | ||
|
r18441 | cleandir = None | ||
|
r26587 | raise error.Abort(_("destination '%s' already exists") | ||
|
r5569 | % dest) | ||
raise | ||||
|
r2597 | |||
|
r15078 | destlock = copystore(ui, srcrepo, destpath) | ||
|
r22646 | # copy bookmarks over | ||
|
r31322 | srcbookmarks = srcrepo.vfs.join('bookmarks') | ||
|
r22646 | dstbookmarks = os.path.join(destpath, 'bookmarks') | ||
if os.path.exists(srcbookmarks): | ||||
util.copyfile(srcbookmarks, dstbookmarks) | ||||
|
r2597 | |||
|
r17740 | dstcachedir = os.path.join(destpath, 'cache') | ||
|
r35784 | for cache in cacheutil.cachetocopy(srcrepo): | ||
r32493 | _copycache(srcrepo, dstcachedir, cache) | |||
|
r17740 | |||
|
r4915 | # we need to re-init the repo after manually copying the data | ||
# into it | ||||
|
r17874 | destpeer = peer(srcrepo, peeropts, dest) | ||
|
r14463 | srcrepo.hook('outgoing', source='clone', | ||
|
r12144 | node=node.hex(node.nullid)) | ||
|
r4915 | else: | ||
|
r5569 | try: | ||
|
r17875 | destpeer = peer(srcrepo or ui, peeropts, dest, create=True) | ||
# only pass ui when no srcrepo | ||||
|
r25660 | except OSError as inst: | ||
|
r5569 | if inst.errno == errno.EEXIST: | ||
|
r18441 | cleandir = None | ||
|
r26587 | raise error.Abort(_("destination '%s' already exists") | ||
|
r5569 | % dest) | ||
raise | ||||
|
r2597 | |||
|
r37279 | if revs: | ||
|
r17191 | if not srcpeer.capable('lookup'): | ||
|
r26587 | raise error.Abort(_("src repository does not support " | ||
|
r9171 | "revision lookup and so doesn't " | ||
"support clone by revision")) | ||||
|
r37279 | revs = [srcpeer.lookup(r) for r in revs] | ||
|
r8417 | checkout = revs[0] | ||
|
r37279 | else: | ||
revs = None | ||||
|
r27165 | local = destpeer.local() | ||
if local: | ||||
|
r35581 | u = util.url(abspath) | ||
defaulturl = bytes(u) | ||||
local.ui.setconfig('paths', 'default', defaulturl, 'clone') | ||||
|
r23545 | if not stream: | ||
if pull: | ||||
stream = False | ||||
else: | ||||
stream = None | ||||
|
r27165 | # internal config: ui.quietbookmarkmove | ||
|
r31456 | overrides = {('ui', 'quietbookmarkmove'): True} | ||
with local.ui.configoverride(overrides, 'clone'): | ||||
|
r27165 | exchange.pull(local, srcpeer, revs, | ||
streamclonerequested=stream) | ||||
|
r17191 | elif srcrepo: | ||
|
r22647 | exchange.push(srcrepo, destpeer, revs=revs, | ||
bookmarks=srcrepo._bookmarks.keys()) | ||||
|
r4915 | else: | ||
|
r26587 | raise error.Abort(_("clone from remote to remote not supported") | ||
) | ||||
|
r2597 | |||
|
r18441 | cleandir = None | ||
|
r2597 | |||
|
r17191 | destrepo = destpeer.local() | ||
if destrepo: | ||||
|
r22837 | template = uimod.samplehgrcs['cloned'] | ||
|
r15552 | u = util.url(abspath) | ||
u.passwd = None | ||||
|
r33650 | defaulturl = bytes(u) | ||
|
r35638 | destrepo.vfs.write('hgrc', util.tonativeeol(template % defaulturl)) | ||
|
r20790 | destrepo.ui.setconfig('paths', 'default', defaulturl, 'clone') | ||
|
r8814 | |||
|
r35332 | if ui.configbool('experimental', 'remotenames'): | ||
|
r35348 | logexchange.pullremotenames(destrepo, srcpeer) | ||
|
r35332 | |||
|
r4915 | if update: | ||
|
r6526 | if update is not True: | ||
|
r17342 | checkout = srcpeer.lookup(update) | ||
|
r17867 | uprev = None | ||
|
r17882 | status = None | ||
|
r17867 | if checkout is not None: | ||
|
r5248 | try: | ||
|
r17867 | uprev = destrepo.lookup(checkout) | ||
|
r9423 | except error.RepoLookupError: | ||
|
r26354 | if update is not True: | ||
try: | ||||
uprev = destrepo.lookup(update) | ||||
except error.RepoLookupError: | ||||
pass | ||||
|
r17867 | if uprev is None: | ||
try: | ||||
uprev = destrepo._bookmarks['@'] | ||||
|
r17870 | update = '@' | ||
|
r17882 | bn = destrepo[uprev].branch() | ||
if bn == 'default': | ||||
status = _("updating to bookmark @\n") | ||||
else: | ||||
|
r20868 | status = (_("updating to bookmark @ on branch %s\n") | ||
|
r26353 | % bn) | ||
|
r17867 | except KeyError: | ||
try: | ||||
uprev = destrepo.branchtip('default') | ||||
except error.RepoLookupError: | ||||
uprev = destrepo.lookup('tip') | ||||
|
r17882 | if not status: | ||
bn = destrepo[uprev].branch() | ||||
status = _("updating to branch %s\n") % bn | ||||
destrepo.ui.status(status) | ||||
|
r14463 | _update(destrepo, uprev) | ||
|
r17703 | if update in destrepo._bookmarks: | ||
|
r24945 | bookmarks.activate(destrepo, update) | ||
|
r4915 | finally: | ||
|
r15908 | release(srclock, destlock) | ||
|
r18441 | if cleandir is not None: | ||
shutil.rmtree(cleandir, True) | ||||
|
r17191 | if srcpeer is not None: | ||
srcpeer.close() | ||||
|
r19313 | return srcpeer, destpeer | ||
|
r2775 | |||
|
r27402 | def _showstats(repo, stats, quietempty=False): | ||
|
r37143 | if quietempty and stats.isempty(): | ||
|
r27402 | return | ||
|
r9454 | repo.ui.status(_("%d files updated, %d files merged, " | ||
|
r37125 | "%d files removed, %d files unresolved\n") % ( | ||
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)""" | ||||
|
r27344 | return mergemod.update(repo, node, False, overwrite, | ||
|
r31166 | labels=['working copy', 'destination'], | ||
updatecheck=updatecheck) | ||||
|
r17895 | |||
|
r31166 | def update(repo, node, quietempty=False, updatecheck=None): | ||
"""update the working directory to node""" | ||||
stats = updaterepo(repo, node, False, updatecheck=updatecheck) | ||||
|
r27404 | _showstats(repo, stats, quietempty) | ||
|
r37143 | if stats.unresolvedcount: | ||
|
r6518 | repo.ui.status(_("use 'hg resolve' to retry unresolved file merges\n")) | ||
|
r37143 | return stats.unresolvedcount > 0 | ||
|
r2775 | |||
|
r7546 | # naming conflict in clone() | ||
_update = update | ||||
|
r27403 | def clean(repo, node, show_stats=True, quietempty=False): | ||
|
r2808 | """forcibly switch the working directory to node, clobbering changes""" | ||
|
r17895 | stats = updaterepo(repo, node, True) | ||
|
r31311 | repo.vfs.unlinkpath('graftstate', ignoremissing=True) | ||
|
r10282 | if show_stats: | ||
|
r27403 | _showstats(repo, stats, quietempty) | ||
|
r37143 | return stats.unresolvedcount > 0 | ||
|
r2775 | |||
|
r28501 | # naming conflict in updatetotally() | ||
_clean = clean | ||||
|
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 | ||
Valid values for updatecheck are (None => linear): | ||||
* 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 | ||||
changes into destination | ||||
|
r31168 | * noconflict: 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: | ||
|
r34706 | updatecheck = ui.config('commands', 'update.check') | ||
|
r31168 | if updatecheck not in ('abort', 'none', 'linear', 'noconflict'): | ||
|
r31167 | # If not configured, or invalid value configured | ||
updatecheck = 'linear' | ||||
|
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: | ||||
|
r31166 | if updatecheck == 'abort': | ||
|
r30963 | cmdutil.bailifchanged(repo, merge=False) | ||
|
r31166 | updatecheck = 'none' | ||
ret = _update(repo, checkout, updatecheck=updatecheck) | ||||
|
r28501 | |||
if not ret and movemarkfrom: | ||||
if movemarkfrom == repo['.'].node(): | ||||
pass # no-op update | ||||
elif bookmarks.update(repo, [movemarkfrom], repo['.'].node()): | ||||
|
r29902 | b = ui.label(repo._activebookmark, 'bookmarks.active') | ||
ui.status(_("updating bookmark %s\n") % b) | ||||
|
r28501 | else: | ||
# this can happen with a non-linear update | ||||
|
r29902 | b = ui.label(repo._activebookmark, 'bookmarks') | ||
ui.status(_("(leaving bookmark %s)\n") % b) | ||||
|
r28501 | bookmarks.deactivate(repo) | ||
elif brev in repo._bookmarks: | ||||
if brev != repo._activebookmark: | ||||
|
r29902 | b = ui.label(brev, 'bookmarks.active') | ||
ui.status(_("(activating bookmark %s)\n") % b) | ||||
|
r28501 | bookmarks.activate(repo, brev) | ||
elif brev: | ||||
if repo._activebookmark: | ||||
|
r29902 | b = ui.label(repo._activebookmark, 'bookmarks') | ||
ui.status(_("(leaving bookmark %s)\n") % b) | ||||
|
r28501 | bookmarks.deactivate(repo) | ||
if warndest: | ||||
destutil.statusotherdests(ui, repo) | ||||
return ret | ||||
|
r35722 | def merge(repo, node, force=None, remind=True, mergeforce=False, labels=None, | ||
abort=False): | ||||
|
r13162 | """Branch merge with node, resolving changes. Return true if any | ||
unresolved conflicts.""" | ||||
|
r35722 | if not abort: | ||
stats = mergemod.update(repo, node, True, force, mergeforce=mergeforce, | ||||
labels=labels) | ||||
else: | ||||
ms = mergemod.mergestate.read(repo) | ||||
if ms.active(): | ||||
# there were conflicts | ||||
|
r35731 | node = ms.localctx.hex() | ||
|
r35722 | else: | ||
# there were no conficts, mergestate was not stored | ||||
node = repo['.'].hex() | ||||
repo.ui.status(_("aborting the merge, updating back to" | ||||
" %s\n") % node[:12]) | ||||
stats = mergemod.update(repo, node, branchmerge=False, force=True, | ||||
labels=labels) | ||||
|
r3316 | _showstats(repo, stats) | ||
|
r37143 | if stats.unresolvedcount: | ||
|
r7821 | repo.ui.status(_("use 'hg resolve' to retry unresolved file merges " | ||
|
r35722 | "or 'hg merge --abort' to abandon\n")) | ||
elif remind and not abort: | ||||
|
r3316 | repo.ui.status(_("(branch merge, don't forget to commit)\n")) | ||
|
r37143 | return stats.unresolvedcount > 0 | ||
|
r2808 | |||
|
r12730 | def _incoming(displaychlist, subreporecurse, ui, repo, source, | ||
opts, buffered=False): | ||||
""" | ||||
Helper for incoming / gincoming. | ||||
displaychlist gets called with | ||||
(remoterepo, incomingchangesetlist, displayer) parameters, | ||||
and is supposed to contain only code that can't be unified. | ||||
""" | ||||
source, branches = parseurl(ui.expandpath(source), opts.get('branch')) | ||||
|
r14556 | other = peer(repo, opts, source) | ||
|
r14076 | ui.status(_('comparing with %s\n') % util.hidepassword(source)) | ||
|
r12730 | revs, checkout = addbranchrevs(repo, other, branches, opts.get('rev')) | ||
if revs: | ||||
revs = [other.lookup(rev) for rev in revs] | ||||
|
r14161 | other, chlist, cleanupfn = bundlerepo.getremotechanges(ui, repo, other, | ||
revs, opts["bundle"], opts["force"]) | ||||
try: | ||||
if not chlist: | ||||
ui.status(_("no changes found\n")) | ||||
return subreporecurse() | ||||
|
r31057 | ui.pager('incoming') | ||
|
r36020 | displayer = logcmdutil.changesetdisplayer(ui, other, opts, | ||
buffered=buffered) | ||||
|
r12730 | displaychlist(other, chlist, displayer) | ||
displayer.close() | ||||
finally: | ||||
|
r14161 | cleanupfn() | ||
|
r12730 | subreporecurse() | ||
return 0 # exit code is zero since we found incoming changes | ||||
|
r12273 | def incoming(ui, repo, source, opts): | ||
|
r12730 | def subreporecurse(): | ||
|
r12400 | ret = 1 | ||
if opts.get('subrepos'): | ||||
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) | ||
|
r12273 | if opts.get('newest_first'): | ||
|
r12729 | chlist.reverse() | ||
|
r12273 | count = 0 | ||
|
r12729 | for n in chlist: | ||
|
r12273 | if limit is not None and count >= limit: | ||
break | ||||
parents = [p for p in other.changelog.parents(n) if p != nullid] | ||||
if opts.get('no_merges') and len(parents) == 2: | ||||
continue | ||||
count += 1 | ||||
displayer.show(other[n]) | ||||
|
r12730 | return _incoming(display, subreporecurse, ui, repo, source, opts) | ||
|
r12273 | |||
|
r12735 | def _outgoing(ui, repo, dest, opts): | ||
|
r35454 | path = ui.paths.getpath(dest, default=('default-push', 'default')) | ||
if not path: | ||||
raise error.Abort(_('default repository not configured!'), | ||||
hint=_("see 'hg help config.paths'")) | ||||
dest = path.pushloc or path.loc | ||||
branches = path.branch, opts.get('branch') or [] | ||||
|
r14076 | ui.status(_('comparing with %s\n') % util.hidepassword(dest)) | ||
|
r12735 | revs, checkout = addbranchrevs(repo, repo, branches, opts.get('rev')) | ||
if revs: | ||||
|
r37329 | revs = [repo[rev].node() for rev in scmutil.revrange(repo, revs)] | ||
|
r12735 | |||
|
r14556 | other = peer(repo, opts, dest) | ||
|
r32172 | outgoing = discovery.findcommonoutgoing(repo, other, revs, | ||
|
r15837 | force=opts.get('force')) | ||
o = outgoing.missing | ||||
|
r12735 | if not o: | ||
|
r17248 | scmutil.nochangesfound(repo.ui, repo, outgoing.excluded) | ||
|
r21050 | return o, other | ||
|
r12735 | |||
|
r12271 | def outgoing(ui, repo, dest, opts): | ||
|
r12400 | def recurse(): | ||
ret = 1 | ||||
if opts.get('subrepos'): | ||||
ctx = repo[None] | ||||
for subpath in sorted(ctx.substate): | ||||
sub = ctx.sub(subpath) | ||||
ret = min(ret, sub.outgoing(ui, dest, opts)) | ||||
return ret | ||||
|
r35906 | limit = logcmdutil.getlimit(opts) | ||
|
r21050 | o, other = _outgoing(ui, repo, dest, opts) | ||
|
r21049 | if not o: | ||
|
r21051 | cmdutil.outgoinghooks(ui, repo, other, opts, o) | ||
|
r12400 | return recurse() | ||
|
r12271 | if opts.get('newest_first'): | ||
o.reverse() | ||||
|
r31058 | ui.pager('outgoing') | ||
|
r35906 | displayer = logcmdutil.changesetdisplayer(ui, repo, opts) | ||
|
r12271 | count = 0 | ||
for n in o: | ||||
if limit is not None and count >= limit: | ||||
break | ||||
parents = [p for p in repo.changelog.parents(n) if p != nullid] | ||||
if opts.get('no_merges') and len(parents) == 2: | ||||
continue | ||||
count += 1 | ||||
displayer.show(repo[n]) | ||||
displayer.close() | ||||
|
r21051 | cmdutil.outgoinghooks(ui, repo, other, opts, o) | ||
|
r12400 | recurse() | ||
return 0 # exit code is zero since we found outgoing changes | ||||
|
r12271 | |||
|
r2778 | def verify(repo): | ||
"""verify the consistency of a repository""" | ||||
|
r25591 | ret = verifymod.verify(repo) | ||
# 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 | ||||
revs = repo.revs("filelog(%s)", | ||||
util.pathto(repo.root, repo.getcwd(), '.hgsubstate')) | ||||
if revs: | ||||
repo.ui.status(_('checking subrepo links\n')) | ||||
for rev in revs: | ||||
ctx = repo[rev] | ||||
try: | ||||
for subpath in ctx.substate: | ||||
|
r29021 | try: | ||
ret = (ctx.sub(subpath, allowcreate=False).verify() | ||||
or ret) | ||||
except error.RepoError as e: | ||||
|
r29645 | repo.ui.warn(('%s: %s\n') % (rev, e)) | ||
|
r25591 | except Exception: | ||
repo.ui.warn(_('.hgsubstate is corrupt in revision %s\n') % | ||||
node.short(ctx.node())) | ||||
return ret | ||||
|
r11273 | |||
def remoteui(src, opts): | ||||
'build a remote ui from ui or repo and opts' | ||||
|
r14952 | if util.safehasattr(src, 'baseui'): # looks like a repository | ||
|
r11273 | 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 | ||||
# copy ssh-specific options | ||||
for o in 'ssh', 'remotecmd': | ||||
v = opts.get(o) or src.config('ui', o) | ||||
if v: | ||||
|
r20790 | dst.setconfig("ui", o, v, 'copied') | ||
|
r11273 | |||
# copy bundle-specific options | ||||
r = src.config('bundle', 'mainreporoot') | ||||
if r: | ||||
|
r20790 | dst.setconfig('bundle', 'mainreporoot', r, 'copied') | ||
|
r11273 | |||
|
r13192 | # copy selected local settings to the remote ui | ||
|
r29616 | for sect in ('auth', 'hostfingerprints', 'hostsecurity', 'http_proxy'): | ||
|
r11273 | for key, val in src.configitems(sect): | ||
|
r20790 | dst.setconfig(sect, key, val, 'copied') | ||
|
r13192 | v = src.config('web', 'cacerts') | ||
|
r29594 | if v: | ||
|
r20790 | dst.setconfig('web', 'cacerts', util.expandpath(v), 'copied') | ||
|
r11273 | |||
return dst | ||||
|
r26219 | |||
# Files of interest | ||||
# Used to check if the repository has changed looking at mtime and size of | ||||
|
r26781 | # these files. | ||
|
r26219 | foi = [('spath', '00changelog.i'), | ||
('spath', 'phaseroots'), # ! phase can change content at the same size | ||||
('spath', 'obsstore'), | ||||
('path', 'bookmarks'), # ! bookmark can change content at the same size | ||||
] | ||||
class cachedlocalrepo(object): | ||||
"""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 | ||||