hg.py
280 lines
| 8.8 KiB
| text/x-python
|
PythonLexer
/ mercurial / hg.py
|
r0 | # hg.py - repository classes for mercurial | ||
# | ||||
|
r2859 | # Copyright 2005, 2006 Matt Mackall <mpm@selenic.com> | ||
# Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com> | ||||
|
r0 | # | ||
# This software may be used and distributed according to the terms | ||||
# of the GNU General Public License, incorporated herein by reference. | ||||
|
r1089 | from node import * | ||
from repo import * | ||||
|
r3891 | from i18n import _ | ||
|
r3877 | import localrepo, bundlerepo, httprepo, sshrepo, statichttprepo | ||
import errno, lock, os, shutil, util | ||||
import merge as _merge | ||||
import verify as _verify | ||||
|
r0 | |||
|
r2740 | def _local(path): | ||
|
r3195 | return (os.path.isfile(util.drop_scheme('file', path)) and | ||
|
r2768 | bundlerepo or localrepo) | ||
|
r2469 | |||
|
r2472 | schemes = { | ||
|
r2740 | 'bundle': bundlerepo, | ||
'file': _local, | ||||
'hg': httprepo, | ||||
'http': httprepo, | ||||
'https': httprepo, | ||||
'old-http': statichttprepo, | ||||
'ssh': sshrepo, | ||||
'static-http': statichttprepo, | ||||
|
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() | ||
|
r2847 | repo_setup_hooks = [] | ||
|
r3195 | def repository(ui, path='', create=False): | ||
|
r2774 | """return a repository object for the specified path""" | ||
|
r2847 | repo = _lookup(path).instance(ui, path, create) | ||
for hook in repo_setup_hooks: | ||||
hook(ui, repo) | ||||
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 | |||
|
r2613 | def clone(ui, source, dest=None, pull=False, rev=None, update=True, | ||
stream=False): | ||||
|
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 | ||||
destination is local repository | ||||
""" | ||||
|
r2719 | if isinstance(source, str): | ||
src_repo = repository(ui, source) | ||||
else: | ||||
src_repo = source | ||||
source = src_repo.url() | ||||
|
r2597 | if dest is None: | ||
|
r2719 | dest = defaultdest(source) | ||
|
r3841 | ui.status(_("destination directory: %s\n") % dest) | ||
|
r2719 | |||
def localpath(path): | ||||
if path.startswith('file://'): | ||||
return path[7:] | ||||
if path.startswith('file:'): | ||||
return path[5:] | ||||
return path | ||||
dest = localpath(dest) | ||||
source = localpath(source) | ||||
|
r2597 | |||
if os.path.exists(dest): | ||||
|
r3072 | raise util.Abort(_("destination '%s' already exists") % dest) | ||
|
r2597 | |||
class DirCleanup(object): | ||||
def __init__(self, dir_): | ||||
self.rmtree = shutil.rmtree | ||||
self.dir_ = dir_ | ||||
def close(self): | ||||
self.dir_ = None | ||||
def __del__(self): | ||||
if self.dir_: | ||||
self.rmtree(self.dir_, True) | ||||
dir_cleanup = None | ||||
|
r3849 | if islocal(dest): | ||
dir_cleanup = DirCleanup(dest) | ||||
|
r2597 | |||
abspath = source | ||||
copy = False | ||||
|
r3849 | if src_repo.local() and islocal(dest): | ||
|
r2597 | abspath = os.path.abspath(source) | ||
copy = not pull and not rev | ||||
src_lock, dest_lock = None, None | ||||
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 | ||||
src_lock = src_repo.lock() | ||||
except lock.LockException: | ||||
copy = False | ||||
if copy: | ||||
|
r3851 | def force_copy(src, dst): | ||
try: | ||||
util.copyfiles(src, dst) | ||||
except OSError, inst: | ||||
if inst.errno != errno.ENOENT: | ||||
raise | ||||
|
r3791 | src_store = os.path.realpath(src_repo.spath) | ||
|
r3849 | if not os.path.exists(dest): | ||
os.mkdir(dest) | ||||
|
r3853 | dest_path = os.path.realpath(os.path.join(dest, ".hg")) | ||
|
r3849 | os.mkdir(dest_path) | ||
|
r3853 | if src_repo.spath != src_repo.path: | ||
dest_store = os.path.join(dest_path, "store") | ||||
os.mkdir(dest_store) | ||||
else: | ||||
dest_store = dest_path | ||||
|
r3851 | # copy the requires file | ||
force_copy(src_repo.join("requires"), | ||||
os.path.join(dest_path, "requires")) | ||||
# we lock here to avoid premature writing to the target | ||||
|
r3791 | dest_lock = lock.lock(os.path.join(dest_store, "lock")) | ||
|
r2597 | |||
|
r3713 | files = ("data", | ||
"00manifest.d", "00manifest.i", | ||||
"00changelog.d", "00changelog.i") | ||||
for f in files: | ||||
|
r3791 | src = os.path.join(src_store, f) | ||
dst = os.path.join(dest_store, f) | ||||
|
r3851 | force_copy(src, dst) | ||
|
r2597 | |||
|
r2631 | # we need to re-init the repo after manually copying the data | ||
# into it | ||||
|
r2597 | dest_repo = repository(ui, dest) | ||
else: | ||||
|
r3849 | dest_repo = repository(ui, dest, create=True) | ||
|
r2597 | revs = None | ||
if rev: | ||||
|
r3448 | if 'lookup' not in src_repo.capabilities: | ||
raise util.Abort(_("src repository does not support revision " | ||||
"lookup and so doesn't support clone by " | ||||
"revision")) | ||||
|
r2597 | revs = [src_repo.lookup(r) for r in rev] | ||
if dest_repo.local(): | ||||
|
r2613 | dest_repo.clone(src_repo, heads=revs, stream=stream) | ||
|
r2597 | elif src_repo.local(): | ||
src_repo.push(dest_repo, revs=revs) | ||||
else: | ||||
raise util.Abort(_("clone from remote to remote not supported")) | ||||
if src_lock: | ||||
src_lock.release() | ||||
if dest_repo.local(): | ||||
fp = dest_repo.opener("hgrc", "w", text=True) | ||||
fp.write("[paths]\n") | ||||
fp.write("default = %s\n" % abspath) | ||||
fp.close() | ||||
if dest_lock: | ||||
dest_lock.release() | ||||
if update: | ||||
|
r3316 | _update(dest_repo, dest_repo.changelog.tip()) | ||
|
r2597 | if dir_cleanup: | ||
dir_cleanup.close() | ||||
return src_repo, dest_repo | ||||
|
r2775 | |||
|
r3316 | def _showstats(repo, stats): | ||
stats = ((stats[0], _("updated")), | ||||
(stats[1], _("merged")), | ||||
(stats[2], _("removed")), | ||||
(stats[3], _("unresolved"))) | ||||
note = ", ".join([_("%d files %s") % s for s in stats]) | ||||
repo.ui.status("%s\n" % note) | ||||
def _update(repo, node): return update(repo, node) | ||||
|
r2808 | def update(repo, node): | ||
"""update the working directory to node, merging linear changes""" | ||||
|
r3869 | pl = repo.parents() | ||
|
r3316 | stats = _merge.update(repo, node, False, False, None, None) | ||
_showstats(repo, stats) | ||||
if stats[3]: | ||||
repo.ui.status(_("There are unresolved merges with" | ||||
" locally modified files.\n")) | ||||
|
r3869 | if stats[1]: | ||
repo.ui.status(_("You can finish the partial merge using:\n")) | ||||
else: | ||||
repo.ui.status(_("You can redo the full merge using:\n")) | ||||
# len(pl)==1, otherwise _merge.update() would have raised util.Abort: | ||||
repo.ui.status(_(" hg update %s\n hg update %s\n") | ||||
% (pl[0].rev(), repo.changectx(node).rev())) | ||||
|
r3316 | return stats[3] | ||
|
r2775 | |||
|
r2808 | def clean(repo, node, wlock=None, show_stats=True): | ||
"""forcibly switch the working directory to node, clobbering changes""" | ||||
|
r3316 | stats = _merge.update(repo, node, False, True, None, wlock) | ||
if show_stats: _showstats(repo, stats) | ||||
return stats[3] | ||||
|
r2775 | |||
|
r2808 | def merge(repo, node, force=None, remind=True, wlock=None): | ||
"""branch merge with node, resolving changes""" | ||||
|
r3316 | stats = _merge.update(repo, node, True, force, False, wlock) | ||
_showstats(repo, stats) | ||||
if stats[3]: | ||||
pl = repo.parents() | ||||
repo.ui.status(_("There are unresolved merges," | ||||
" you can redo the full merge using:\n" | ||||
" hg update -C %s\n" | ||||
|
r3679 | " hg merge %s\n") | ||
|
r3680 | % (pl[0].rev(), pl[1].rev())) | ||
|
r3316 | elif remind: | ||
repo.ui.status(_("(branch merge, don't forget to commit)\n")) | ||||
return stats[3] | ||||
|
r2808 | |||
|
r2812 | def revert(repo, node, choose, wlock): | ||
|
r2808 | """revert changes to revision in node without updating dirstate""" | ||
|
r3316 | return _merge.update(repo, node, False, True, choose, wlock)[3] | ||
|
r2778 | |||
def verify(repo): | ||||
"""verify the consistency of a repository""" | ||||
return _verify.verify(repo) | ||||