hg.py
429 lines
| 14.0 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 | |||
|
r3891 | from i18n import _ | ||
|
r8109 | from lock import release | ||
|
r3877 | import localrepo, bundlerepo, httprepo, sshrepo, statichttprepo | ||
|
r10365 | import lock, util, extensions, error, encoding, node | ||
|
r10651 | import merge as mergemod | ||
import verify as verifymod | ||||
|
r8312 | import errno, os, shutil | ||
|
r0 | |||
|
r2740 | def _local(path): | ||
|
r11154 | path = util.expandpath(util.drop_scheme('file', path)) | ||
return (os.path.isfile(path) and bundlerepo or localrepo) | ||||
|
r2469 | |||
|
r10365 | def addbranchrevs(lrepo, repo, branches, revs): | ||
if not branches: | ||||
return revs or None, revs and revs[0] or None | ||||
|
r10380 | revs = revs and list(revs) or [] | ||
if not repo.capable('branchmap'): | ||||
revs.extend(branches) | ||||
return revs, revs[0] | ||||
|
r10365 | branchmap = repo.branchmap() | ||
for branch in branches: | ||||
if branch == '.': | ||||
if not lrepo or not lrepo.local(): | ||||
raise util.Abort(_("dirstate branch not accessible")) | ||||
|
r11306 | butf8 = lrepo.dirstate.branch() | ||
branch = encoding.tolocal(butf8) | ||||
else: | ||||
butf8 = encoding.fromlocal(branch) | ||||
|
r11299 | if butf8 in branchmap: | ||
revs.extend(node.hex(r) for r in reversed(branchmap[butf8])) | ||||
|
r10365 | else: | ||
|
r11299 | revs.append(branch) | ||
|
r10365 | return revs, revs[0] | ||
def parseurl(url, branches=None): | ||||
'''parse url#branch, returning url, branches+[branch]''' | ||||
|
r5177 | |||
if '#' not in url: | ||||
|
r10365 | return url, branches or [] | ||
|
r7045 | url, branch = url.split('#', 1) | ||
|
r10365 | return url, (branches or []) + [branch] | ||
|
r5177 | |||
|
r2472 | schemes = { | ||
|
r2740 | 'bundle': bundlerepo, | ||
'file': _local, | ||||
'http': httprepo, | ||||
'https': httprepo, | ||||
'ssh': sshrepo, | ||||
'static-http': statichttprepo, | ||||
|
r4853 | } | ||
|
r2469 | |||
|
r2740 | def _lookup(path): | ||
scheme = 'file' | ||||
if path: | ||||
c = path.find(':') | ||||
if c > 0: | ||||
scheme = path[:c] | ||||
thing = schemes.get(scheme) or schemes['file'] | ||||
try: | ||||
return thing(path) | ||||
except TypeError: | ||||
return thing | ||||
|
r2775 | |||
|
r2719 | def islocal(repo): | ||
'''return true if repo or path is local''' | ||||
if isinstance(repo, str): | ||||
|
r2740 | try: | ||
return _lookup(repo).islocal(repo) | ||||
except AttributeError: | ||||
return False | ||||
|
r2719 | return repo.local() | ||
|
r3195 | def repository(ui, path='', create=False): | ||
|
r2774 | """return a repository object for the specified path""" | ||
|
r2847 | repo = _lookup(path).instance(ui, path, create) | ||
|
r4074 | ui = getattr(repo, "ui", ui) | ||
|
r5192 | for name, module in extensions.extensions(): | ||
hook = getattr(module, 'reposetup', None) | ||||
if hook: | ||||
hook(ui, repo) | ||||
|
r2847 | return repo | ||
|
r2597 | |||
|
r2719 | def defaultdest(source): | ||
'''return default destination of clone if none is given''' | ||||
return os.path.basename(os.path.normpath(source)) | ||||
|
r2774 | |||
|
r6524 | def localpath(path): | ||
if path.startswith('file://localhost/'): | ||||
return path[16:] | ||||
if path.startswith('file://'): | ||||
return path[7:] | ||||
if path.startswith('file:'): | ||||
return path[5:] | ||||
return path | ||||
|
r8807 | def share(ui, source, dest=None, update=True): | ||
|
r8800 | '''create a shared repository''' | ||
if not islocal(source): | ||||
raise util.Abort(_('can only share local repositories')) | ||||
|
r8807 | if not dest: | ||
|
r10099 | dest = defaultdest(source) | ||
|
r9344 | else: | ||
dest = ui.expandpath(dest) | ||||
|
r8807 | |||
|
r8800 | if isinstance(source, str): | ||
origsource = ui.expandpath(source) | ||||
|
r10365 | source, branches = parseurl(origsource) | ||
|
r8800 | srcrepo = repository(ui, source) | ||
|
r10365 | rev, checkout = addbranchrevs(srcrepo, srcrepo, branches, None) | ||
|
r8800 | else: | ||
srcrepo = source | ||||
origsource = source = srcrepo.url() | ||||
checkout = None | ||||
sharedpath = srcrepo.sharedpath # if our source is already sharing | ||||
root = os.path.realpath(dest) | ||||
roothg = os.path.join(root, '.hg') | ||||
if os.path.exists(roothg): | ||||
raise util.Abort(_('destination already exists')) | ||||
if not os.path.isdir(root): | ||||
os.mkdir(root) | ||||
os.mkdir(roothg) | ||||
requirements = '' | ||||
try: | ||||
requirements = srcrepo.opener('requires').read() | ||||
except IOError, inst: | ||||
if inst.errno != errno.ENOENT: | ||||
raise | ||||
requirements += 'shared\n' | ||||
file(os.path.join(roothg, 'requires'), 'w').write(requirements) | ||||
file(os.path.join(roothg, 'sharedpath'), 'w').write(sharedpath) | ||||
default = srcrepo.ui.config('paths', 'default') | ||||
if default: | ||||
f = file(os.path.join(roothg, 'hgrc'), 'w') | ||||
f.write('[paths]\ndefault = %s\n' % default) | ||||
f.close() | ||||
r = repository(ui, root) | ||||
if update: | ||||
r.ui.status(_("updating working directory\n")) | ||||
if update is not True: | ||||
checkout = update | ||||
for test in (checkout, 'default', 'tip'): | ||||
|
r9423 | if test is None: | ||
continue | ||||
|
r8800 | try: | ||
uprev = r.lookup(test) | ||||
break | ||||
|
r9423 | except error.RepoLookupError: | ||
|
r8800 | continue | ||
_update(r, uprev) | ||||
|
r2613 | def clone(ui, source, dest=None, pull=False, rev=None, update=True, | ||
|
r10379 | stream=False, branch=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 | ||||
function. Returns a pair of repository objects, the source and | ||||
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) | ||||
pull: always pull from source repository, even in local case | ||||
|
r2621 | stream: stream raw data uncompressed from repository (fast over | ||
LAN, slow over WAN) | ||||
|
r2613 | |||
|
r2597 | rev: revision to clone up to (implies pull=True) | ||
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 | ||||
|
r2597 | """ | ||
|
r4478 | |||
|
r2719 | if isinstance(source, str): | ||
|
r6089 | origsource = ui.expandpath(source) | ||
|
r10379 | source, branch = parseurl(origsource, branch) | ||
|
r2719 | src_repo = repository(ui, source) | ||
else: | ||||
src_repo = source | ||||
|
r10728 | branch = None | ||
|
r6089 | origsource = source = src_repo.url() | ||
|
r10365 | rev, checkout = addbranchrevs(src_repo, src_repo, branch, rev) | ||
|
r2719 | |||
|
r2597 | if dest is None: | ||
|
r2719 | dest = defaultdest(source) | ||
|
r3841 | ui.status(_("destination directory: %s\n") % dest) | ||
|
r9344 | else: | ||
dest = ui.expandpath(dest) | ||||
|
r2719 | |||
dest = localpath(dest) | ||||
source = localpath(source) | ||||
|
r2597 | |||
if os.path.exists(dest): | ||||
|
r7927 | if not os.path.isdir(dest): | ||
raise util.Abort(_("destination '%s' already exists") % dest) | ||||
elif os.listdir(dest): | ||||
raise util.Abort(_("destination '%s' is not empty") % dest) | ||||
|
r2597 | |||
class DirCleanup(object): | ||||
def __init__(self, dir_): | ||||
self.rmtree = shutil.rmtree | ||||
self.dir_ = dir_ | ||||
def close(self): | ||||
self.dir_ = None | ||||
|
r8110 | def cleanup(self): | ||
|
r2597 | if self.dir_: | ||
self.rmtree(self.dir_, True) | ||||
|
r4915 | src_lock = dest_lock = dir_cleanup = None | ||
try: | ||||
if islocal(dest): | ||||
dir_cleanup = DirCleanup(dest) | ||||
|
r2597 | |||
|
r4915 | abspath = origsource | ||
copy = False | ||||
|
r6315 | if src_repo.cancopy() and islocal(dest): | ||
|
r5248 | abspath = os.path.abspath(util.drop_scheme('file', origsource)) | ||
|
r4915 | copy = not pull and not rev | ||
|
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 | ||||
|
r8649 | src_lock = src_repo.lock(wait=False) | ||
|
r7640 | except error.LockError: | ||
|
r4915 | copy = False | ||
|
r2597 | |||
|
r4915 | if copy: | ||
|
r8907 | src_repo.hook('preoutgoing', throw=True, source='clone') | ||
|
r7935 | 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 | ||||
dir_cleanup.dir_ = hgdir | ||||
|
r5569 | try: | ||
|
r7935 | dest_path = hgdir | ||
|
r5569 | os.mkdir(dest_path) | ||
except OSError, inst: | ||||
if inst.errno == errno.EEXIST: | ||||
dir_cleanup.close() | ||||
raise util.Abort(_("destination '%s' already exists") | ||||
% dest) | ||||
raise | ||||
|
r2597 | |||
|
r11255 | hardlink = None | ||
|
r11251 | num = 0 | ||
|
r6903 | for f in src_repo.store.copylist(): | ||
|
r9984 | src = os.path.join(src_repo.sharedpath, f) | ||
|
r6944 | dst = os.path.join(dest_path, f) | ||
dstbase = os.path.dirname(dst) | ||||
if dstbase and not os.path.exists(dstbase): | ||||
os.mkdir(dstbase) | ||||
|
r6903 | if os.path.exists(src): | ||
if dst.endswith('data'): | ||||
# lock to avoid premature writing to the target | ||||
dest_lock = lock.lock(os.path.join(dstbase, "lock")) | ||||
|
r11251 | hardlink, n = util.copyfiles(src, dst, hardlink) | ||
num += n | ||||
if hardlink: | ||||
ui.debug("linked %d files\n" % num) | ||||
else: | ||||
ui.debug("copied %d files\n" % num) | ||||
|
r2597 | |||
|
r4915 | # we need to re-init the repo after manually copying the data | ||
# into it | ||||
dest_repo = repository(ui, dest) | ||||
|
r8907 | src_repo.hook('outgoing', source='clone', node='0'*40) | ||
|
r4915 | else: | ||
|
r5569 | try: | ||
dest_repo = repository(ui, dest, create=True) | ||||
except OSError, inst: | ||||
if inst.errno == errno.EEXIST: | ||||
dir_cleanup.close() | ||||
raise util.Abort(_("destination '%s' already exists") | ||||
% dest) | ||||
raise | ||||
|
r2597 | |||
|
r4915 | revs = None | ||
if rev: | ||||
if 'lookup' not in src_repo.capabilities: | ||||
|
r9171 | raise util.Abort(_("src repository does not support " | ||
"revision lookup and so doesn't " | ||||
"support clone by revision")) | ||||
|
r4915 | revs = [src_repo.lookup(r) for r in rev] | ||
|
r8417 | checkout = revs[0] | ||
|
r4915 | if dest_repo.local(): | ||
dest_repo.clone(src_repo, heads=revs, stream=stream) | ||||
elif src_repo.local(): | ||||
src_repo.push(dest_repo, revs=revs) | ||||
else: | ||||
raise util.Abort(_("clone from remote to remote not supported")) | ||||
|
r2597 | |||
|
r5186 | if dir_cleanup: | ||
dir_cleanup.close() | ||||
|
r2597 | |||
if dest_repo.local(): | ||||
|
r4915 | fp = dest_repo.opener("hgrc", "w", text=True) | ||
fp.write("[paths]\n") | ||||
|
r8179 | fp.write("default = %s\n" % abspath) | ||
|
r4915 | fp.close() | ||
|
r5185 | |||
|
r8814 | dest_repo.ui.setconfig('paths', 'default', abspath) | ||
|
r4915 | if update: | ||
|
r6526 | if update is not True: | ||
checkout = update | ||||
|
r9714 | if src_repo.local(): | ||
checkout = src_repo.lookup(update) | ||||
|
r7045 | for test in (checkout, 'default', 'tip'): | ||
|
r9423 | if test is None: | ||
continue | ||||
|
r5248 | try: | ||
|
r7045 | uprev = dest_repo.lookup(test) | ||
break | ||||
|
r9423 | except error.RepoLookupError: | ||
|
r7045 | continue | ||
|
r9611 | bn = dest_repo[uprev].branch() | ||
|
r9788 | dest_repo.ui.status(_("updating to branch %s\n") | ||
% encoding.tolocal(bn)) | ||||
|
r7045 | _update(dest_repo, uprev) | ||
|
r2597 | |||
|
r4915 | return src_repo, dest_repo | ||
finally: | ||||
|
r8109 | release(src_lock, dest_lock) | ||
|
r8110 | if dir_cleanup is not None: | ||
dir_cleanup.cleanup() | ||||
|
r2775 | |||
|
r3316 | def _showstats(repo, stats): | ||
|
r9454 | repo.ui.status(_("%d files updated, %d files merged, " | ||
"%d files removed, %d files unresolved\n") % stats) | ||||
|
r3316 | |||
|
r2808 | def update(repo, node): | ||
"""update the working directory to node, merging linear changes""" | ||||
|
r10651 | stats = mergemod.update(repo, node, False, False, None) | ||
|
r3316 | _showstats(repo, stats) | ||
if stats[3]: | ||||
|
r6518 | repo.ui.status(_("use 'hg resolve' to retry unresolved file merges\n")) | ||
|
r5635 | return stats[3] > 0 | ||
|
r2775 | |||
|
r7546 | # naming conflict in clone() | ||
_update = update | ||||
|
r4917 | def clean(repo, node, show_stats=True): | ||
|
r2808 | """forcibly switch the working directory to node, clobbering changes""" | ||
|
r10651 | stats = mergemod.update(repo, node, False, True, None) | ||
|
r10282 | if show_stats: | ||
_showstats(repo, stats) | ||||
|
r5635 | return stats[3] > 0 | ||
|
r2775 | |||
|
r4917 | def merge(repo, node, force=None, remind=True): | ||
|
r2808 | """branch merge with node, resolving changes""" | ||
|
r10651 | stats = mergemod.update(repo, node, True, force, False) | ||
|
r3316 | _showstats(repo, stats) | ||
if stats[3]: | ||||
|
r7821 | repo.ui.status(_("use 'hg resolve' to retry unresolved file merges " | ||
|
r9468 | "or 'hg update -C' to abandon\n")) | ||
|
r3316 | elif remind: | ||
repo.ui.status(_("(branch merge, don't forget to commit)\n")) | ||||
|
r5635 | return stats[3] > 0 | ||
|
r2808 | |||
|
r4917 | def revert(repo, node, choose): | ||
|
r2808 | """revert changes to revision in node without updating dirstate""" | ||
|
r10651 | return mergemod.update(repo, node, False, True, choose)[3] > 0 | ||
|
r2778 | |||
def verify(repo): | ||||
"""verify the consistency of a repository""" | ||||
|
r10651 | return verifymod.verify(repo) | ||
|
r11273 | |||
def remoteui(src, opts): | ||||
'build a remote ui from ui or repo and opts' | ||||
if hasattr(src, 'baseui'): # looks like a repository | ||||
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: | ||||
dst.setconfig("ui", o, v) | ||||
# copy bundle-specific options | ||||
r = src.config('bundle', 'mainreporoot') | ||||
if r: | ||||
dst.setconfig('bundle', 'mainreporoot', r) | ||||
# copy auth and http_proxy section settings | ||||
for sect in ('auth', 'http_proxy'): | ||||
for key, val in src.configitems(sect): | ||||
dst.setconfig(sect, key, val) | ||||
return dst | ||||