overrides.py
904 lines
| 33.3 KiB
| text/x-python
|
PythonLexer
|
r15168 | # Copyright 2009-2010 Gregory P. Ward | ||
# Copyright 2009-2010 Intelerad Medical Systems Incorporated | ||||
# Copyright 2010-2011 Fog Creek Software | ||||
# Copyright 2010-2011 Unity Technologies | ||||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
# GNU General Public License version 2 or any later version. | ||||
'''Overridden Mercurial commands and functions for the largefiles extension''' | ||||
import os | ||||
import copy | ||||
from mercurial import hg, commands, util, cmdutil, match as match_, node, \ | ||||
archival, error, merge | ||||
from mercurial.i18n import _ | ||||
from mercurial.node import hex | ||||
from hgext import rebase | ||||
try: | ||||
from mercurial import scmutil | ||||
except ImportError: | ||||
pass | ||||
import lfutil | ||||
import lfcommands | ||||
def installnormalfilesmatchfn(manifest): | ||||
'''overrides scmutil.match so that the matcher it returns will ignore all | ||||
largefiles''' | ||||
oldmatch = None # for the closure | ||||
def override_match(repo, pats=[], opts={}, globbed=False, | ||||
default='relpath'): | ||||
match = oldmatch(repo, pats, opts, globbed, default) | ||||
m = copy.copy(match) | ||||
notlfile = lambda f: not (lfutil.isstandin(f) or lfutil.standin(f) in | ||||
manifest) | ||||
m._files = filter(notlfile, m._files) | ||||
m._fmap = set(m._files) | ||||
orig_matchfn = m.matchfn | ||||
m.matchfn = lambda f: notlfile(f) and orig_matchfn(f) or None | ||||
return m | ||||
oldmatch = installmatchfn(override_match) | ||||
def installmatchfn(f): | ||||
try: | ||||
# Mercurial >= 1.9 | ||||
oldmatch = scmutil.match | ||||
except ImportError: | ||||
# Mercurial <= 1.8 | ||||
oldmatch = cmdutil.match | ||||
setattr(f, 'oldmatch', oldmatch) | ||||
try: | ||||
# Mercurial >= 1.9 | ||||
scmutil.match = f | ||||
except ImportError: | ||||
# Mercurial <= 1.8 | ||||
cmdutil.match = f | ||||
return oldmatch | ||||
def restorematchfn(): | ||||
'''restores scmutil.match to what it was before installnormalfilesmatchfn | ||||
was called. no-op if scmutil.match is its original function. | ||||
Note that n calls to installnormalfilesmatchfn will require n calls to | ||||
restore matchfn to reverse''' | ||||
try: | ||||
# Mercurial >= 1.9 | ||||
scmutil.match = getattr(scmutil.match, 'oldmatch', scmutil.match) | ||||
except ImportError: | ||||
# Mercurial <= 1.8 | ||||
cmdutil.match = getattr(cmdutil.match, 'oldmatch', cmdutil.match) | ||||
# -- Wrappers: modify existing commands -------------------------------- | ||||
# Add works by going through the files that the user wanted to add | ||||
# and checking if they should be added as lfiles. Then making a new | ||||
# matcher which matches only the normal files and running the original | ||||
# version of add. | ||||
def override_add(orig, ui, repo, *pats, **opts): | ||||
large = opts.pop('large', None) | ||||
lfsize = opts.pop('lfsize', None) | ||||
if not lfsize and lfutil.islfilesrepo(repo): | ||||
lfsize = ui.config(lfutil.longname, 'size', default='10') | ||||
if lfsize: | ||||
try: | ||||
lfsize = int(lfsize) | ||||
except ValueError: | ||||
|
r15170 | raise util.Abort(_('largefiles: size must be an integer, was %s\n') | ||
% lfsize) | ||||
|
r15168 | |||
lfmatcher = None | ||||
if os.path.exists(repo.wjoin(lfutil.shortname)): | ||||
lfpats = ui.config(lfutil.longname, 'patterns', default=()) | ||||
if lfpats: | ||||
lfpats = lfpats.split(' ') | ||||
lfmatcher = match_.match(repo.root, '', list(lfpats)) | ||||
lfnames = [] | ||||
try: | ||||
# Mercurial >= 1.9 | ||||
m = scmutil.match(repo[None], pats, opts) | ||||
except ImportError: | ||||
# Mercurial <= 1.8 | ||||
m = cmdutil.match(repo, pats, opts) | ||||
m.bad = lambda x, y: None | ||||
wctx = repo[None] | ||||
for f in repo.walk(m): | ||||
exact = m.exact(f) | ||||
lfile = lfutil.standin(f) in wctx | ||||
nfile = f in wctx | ||||
exists = lfile or nfile | ||||
# Don't warn the user when they attempt to add a normal tracked file. | ||||
# The normal add code will do that for us. | ||||
if exact and exists: | ||||
if lfile: | ||||
ui.warn(_('%s already a largefile\n') % f) | ||||
continue | ||||
if exact or not exists: | ||||
if large or (lfsize and os.path.getsize(repo.wjoin(f)) >= \ | ||||
lfsize * 1024 * 1024) or (lfmatcher and lfmatcher(f)): | ||||
lfnames.append(f) | ||||
if ui.verbose or not exact: | ||||
ui.status(_('adding %s as a largefile\n') % m.rel(f)) | ||||
bad = [] | ||||
standins = [] | ||||
# Need to lock otherwise there could be a race condition inbetween when | ||||
# standins are created and added to the repo | ||||
wlock = repo.wlock() | ||||
try: | ||||
if not opts.get('dry_run'): | ||||
lfdirstate = lfutil.openlfdirstate(ui, repo) | ||||
for f in lfnames: | ||||
standinname = lfutil.standin(f) | ||||
lfutil.writestandin(repo, standinname, hash='', | ||||
executable=lfutil.getexecutable(repo.wjoin(f))) | ||||
standins.append(standinname) | ||||
if lfdirstate[f] == 'r': | ||||
lfdirstate.normallookup(f) | ||||
else: | ||||
lfdirstate.add(f) | ||||
lfdirstate.write() | ||||
bad += [lfutil.splitstandin(f) for f in lfutil.repo_add(repo, | ||||
standins) if f in m.files()] | ||||
finally: | ||||
wlock.release() | ||||
installnormalfilesmatchfn(repo[None].manifest()) | ||||
result = orig(ui, repo, *pats, **opts) | ||||
restorematchfn() | ||||
return (result == 1 or bad) and 1 or 0 | ||||
def override_remove(orig, ui, repo, *pats, **opts): | ||||
manifest = repo[None].manifest() | ||||
installnormalfilesmatchfn(manifest) | ||||
orig(ui, repo, *pats, **opts) | ||||
restorematchfn() | ||||
after, force = opts.get('after'), opts.get('force') | ||||
if not pats and not after: | ||||
raise util.Abort(_('no files specified')) | ||||
try: | ||||
# Mercurial >= 1.9 | ||||
m = scmutil.match(repo[None], pats, opts) | ||||
except ImportError: | ||||
# Mercurial <= 1.8 | ||||
m = cmdutil.match(repo, pats, opts) | ||||
try: | ||||
repo.lfstatus = True | ||||
s = repo.status(match=m, clean=True) | ||||
finally: | ||||
repo.lfstatus = False | ||||
modified, added, deleted, clean = [[f for f in list if lfutil.standin(f) \ | ||||
in manifest] for list in [s[0], s[1], s[3], s[6]]] | ||||
def warn(files, reason): | ||||
for f in files: | ||||
ui.warn(_('not removing %s: file %s (use -f to force removal)\n') | ||||
% (m.rel(f), reason)) | ||||
if force: | ||||
remove, forget = modified + deleted + clean, added | ||||
elif after: | ||||
remove, forget = deleted, [] | ||||
warn(modified + added + clean, _('still exists')) | ||||
else: | ||||
remove, forget = deleted + clean, [] | ||||
warn(modified, _('is modified')) | ||||
warn(added, _('has been marked for add')) | ||||
for f in sorted(remove + forget): | ||||
if ui.verbose or not m.exact(f): | ||||
ui.status(_('removing %s\n') % m.rel(f)) | ||||
# Need to lock because standin files are deleted then removed from the | ||||
# repository and we could race inbetween. | ||||
wlock = repo.wlock() | ||||
try: | ||||
lfdirstate = lfutil.openlfdirstate(ui, repo) | ||||
for f in remove: | ||||
if not after: | ||||
os.unlink(repo.wjoin(f)) | ||||
currentdir = os.path.split(f)[0] | ||||
while currentdir and not os.listdir(repo.wjoin(currentdir)): | ||||
os.rmdir(repo.wjoin(currentdir)) | ||||
currentdir = os.path.split(currentdir)[0] | ||||
lfdirstate.remove(f) | ||||
lfdirstate.write() | ||||
forget = [lfutil.standin(f) for f in forget] | ||||
remove = [lfutil.standin(f) for f in remove] | ||||
lfutil.repo_forget(repo, forget) | ||||
lfutil.repo_remove(repo, remove, unlink=True) | ||||
finally: | ||||
wlock.release() | ||||
def override_status(orig, ui, repo, *pats, **opts): | ||||
try: | ||||
repo.lfstatus = True | ||||
return orig(ui, repo, *pats, **opts) | ||||
finally: | ||||
repo.lfstatus = False | ||||
def override_log(orig, ui, repo, *pats, **opts): | ||||
try: | ||||
repo.lfstatus = True | ||||
orig(ui, repo, *pats, **opts) | ||||
finally: | ||||
repo.lfstatus = False | ||||
def override_verify(orig, ui, repo, *pats, **opts): | ||||
large = opts.pop('large', False) | ||||
all = opts.pop('lfa', False) | ||||
contents = opts.pop('lfc', False) | ||||
result = orig(ui, repo, *pats, **opts) | ||||
if large: | ||||
result = result or lfcommands.verifylfiles(ui, repo, all, contents) | ||||
return result | ||||
# Override needs to refresh standins so that update's normal merge | ||||
# will go through properly. Then the other update hook (overriding repo.update) | ||||
# will get the new files. Filemerge is also overriden so that the merge | ||||
# will merge standins correctly. | ||||
def override_update(orig, ui, repo, *pats, **opts): | ||||
lfdirstate = lfutil.openlfdirstate(ui, repo) | ||||
s = lfdirstate.status(match_.always(repo.root, repo.getcwd()), [], False, | ||||
False, False) | ||||
(unsure, modified, added, removed, missing, unknown, ignored, clean) = s | ||||
# Need to lock between the standins getting updated and their lfiles | ||||
# getting updated | ||||
wlock = repo.wlock() | ||||
try: | ||||
if opts['check']: | ||||
mod = len(modified) > 0 | ||||
for lfile in unsure: | ||||
standin = lfutil.standin(lfile) | ||||
if repo['.'][standin].data().strip() != \ | ||||
lfutil.hashfile(repo.wjoin(lfile)): | ||||
mod = True | ||||
else: | ||||
lfdirstate.normal(lfile) | ||||
lfdirstate.write() | ||||
if mod: | ||||
raise util.Abort(_('uncommitted local changes')) | ||||
# XXX handle removed differently | ||||
if not opts['clean']: | ||||
for lfile in unsure + modified + added: | ||||
lfutil.updatestandin(repo, lfutil.standin(lfile)) | ||||
finally: | ||||
wlock.release() | ||||
return orig(ui, repo, *pats, **opts) | ||||
# Override filemerge to prompt the user about how they wish to merge lfiles. | ||||
# This will handle identical edits, and copy/rename + edit without prompting | ||||
# the user. | ||||
def override_filemerge(origfn, repo, mynode, orig, fcd, fco, fca): | ||||
# Use better variable names here. Because this is a wrapper we cannot | ||||
# change the variable names in the function declaration. | ||||
fcdest, fcother, fcancestor = fcd, fco, fca | ||||
if not lfutil.isstandin(orig): | ||||
return origfn(repo, mynode, orig, fcdest, fcother, fcancestor) | ||||
else: | ||||
if not fcother.cmp(fcdest): # files identical? | ||||
return None | ||||
# backwards, use working dir parent as ancestor | ||||
if fcancestor == fcother: | ||||
fcancestor = fcdest.parents()[0] | ||||
if orig != fcother.path(): | ||||
repo.ui.status(_('merging %s and %s to %s\n') | ||||
% (lfutil.splitstandin(orig), | ||||
lfutil.splitstandin(fcother.path()), | ||||
lfutil.splitstandin(fcdest.path()))) | ||||
else: | ||||
repo.ui.status(_('merging %s\n') | ||||
% lfutil.splitstandin(fcdest.path())) | ||||
if fcancestor.path() != fcother.path() and fcother.data() == \ | ||||
fcancestor.data(): | ||||
return 0 | ||||
if fcancestor.path() != fcdest.path() and fcdest.data() == \ | ||||
fcancestor.data(): | ||||
repo.wwrite(fcdest.path(), fcother.data(), fcother.flags()) | ||||
return 0 | ||||
if repo.ui.promptchoice(_('largefile %s has a merge conflict\n' | ||||
'keep (l)ocal or take (o)ther?') % | ||||
lfutil.splitstandin(orig), | ||||
(_('&Local'), _('&Other')), 0) == 0: | ||||
return 0 | ||||
else: | ||||
repo.wwrite(fcdest.path(), fcother.data(), fcother.flags()) | ||||
return 0 | ||||
# Copy first changes the matchers to match standins instead of lfiles. | ||||
# Then it overrides util.copyfile in that function it checks if the destination | ||||
# lfile already exists. It also keeps a list of copied files so that the lfiles | ||||
# can be copied and the dirstate updated. | ||||
def override_copy(orig, ui, repo, pats, opts, rename=False): | ||||
# doesn't remove lfile on rename | ||||
if len(pats) < 2: | ||||
# this isn't legal, let the original function deal with it | ||||
return orig(ui, repo, pats, opts, rename) | ||||
def makestandin(relpath): | ||||
try: | ||||
# Mercurial >= 1.9 | ||||
path = scmutil.canonpath(repo.root, repo.getcwd(), relpath) | ||||
except ImportError: | ||||
# Mercurial <= 1.8 | ||||
path = util.canonpath(repo.root, repo.getcwd(), relpath) | ||||
return os.path.join(os.path.relpath('.', repo.getcwd()), | ||||
lfutil.standin(path)) | ||||
try: | ||||
# Mercurial >= 1.9 | ||||
fullpats = scmutil.expandpats(pats) | ||||
except ImportError: | ||||
# Mercurial <= 1.8 | ||||
fullpats = cmdutil.expandpats(pats) | ||||
dest = fullpats[-1] | ||||
if os.path.isdir(dest): | ||||
if not os.path.isdir(makestandin(dest)): | ||||
os.makedirs(makestandin(dest)) | ||||
# This could copy both lfiles and normal files in one command, but we don't | ||||
# want to do that first replace their matcher to only match normal files | ||||
# and run it then replace it to just match lfiles and run it again | ||||
nonormalfiles = False | ||||
nolfiles = False | ||||
try: | ||||
installnormalfilesmatchfn(repo[None].manifest()) | ||||
result = orig(ui, repo, pats, opts, rename) | ||||
except util.Abort, e: | ||||
if str(e) != 'no files to copy': | ||||
raise e | ||||
else: | ||||
nonormalfiles = True | ||||
result = 0 | ||||
finally: | ||||
restorematchfn() | ||||
# The first rename can cause our current working directory to be removed. | ||||
# In that case there is nothing left to copy/rename so just quit. | ||||
try: | ||||
repo.getcwd() | ||||
except OSError: | ||||
return result | ||||
try: | ||||
# When we call orig below it creates the standins but we don't add them | ||||
# to the dir state until later so lock during that time. | ||||
wlock = repo.wlock() | ||||
manifest = repo[None].manifest() | ||||
oldmatch = None # for the closure | ||||
def override_match(repo, pats=[], opts={}, globbed=False, | ||||
default='relpath'): | ||||
newpats = [] | ||||
# The patterns were previously mangled to add the standin | ||||
# directory; we need to remove that now | ||||
for pat in pats: | ||||
if match_.patkind(pat) is None and lfutil.shortname in pat: | ||||
newpats.append(pat.replace(lfutil.shortname, '')) | ||||
else: | ||||
newpats.append(pat) | ||||
match = oldmatch(repo, newpats, opts, globbed, default) | ||||
m = copy.copy(match) | ||||
lfile = lambda f: lfutil.standin(f) in manifest | ||||
m._files = [lfutil.standin(f) for f in m._files if lfile(f)] | ||||
m._fmap = set(m._files) | ||||
orig_matchfn = m.matchfn | ||||
m.matchfn = lambda f: lfutil.isstandin(f) and \ | ||||
lfile(lfutil.splitstandin(f)) and \ | ||||
orig_matchfn(lfutil.splitstandin(f)) or None | ||||
return m | ||||
oldmatch = installmatchfn(override_match) | ||||
listpats = [] | ||||
for pat in pats: | ||||
if match_.patkind(pat) is not None: | ||||
listpats.append(pat) | ||||
else: | ||||
listpats.append(makestandin(pat)) | ||||
try: | ||||
origcopyfile = util.copyfile | ||||
copiedfiles = [] | ||||
def override_copyfile(src, dest): | ||||
if lfutil.shortname in src and lfutil.shortname in dest: | ||||
destlfile = dest.replace(lfutil.shortname, '') | ||||
if not opts['force'] and os.path.exists(destlfile): | ||||
raise IOError('', | ||||
_('destination largefile already exists')) | ||||
copiedfiles.append((src, dest)) | ||||
origcopyfile(src, dest) | ||||
util.copyfile = override_copyfile | ||||
result += orig(ui, repo, listpats, opts, rename) | ||||
finally: | ||||
util.copyfile = origcopyfile | ||||
lfdirstate = lfutil.openlfdirstate(ui, repo) | ||||
for (src, dest) in copiedfiles: | ||||
if lfutil.shortname in src and lfutil.shortname in dest: | ||||
srclfile = src.replace(lfutil.shortname, '') | ||||
destlfile = dest.replace(lfutil.shortname, '') | ||||
destlfiledir = os.path.dirname(destlfile) or '.' | ||||
if not os.path.isdir(destlfiledir): | ||||
os.makedirs(destlfiledir) | ||||
if rename: | ||||
os.rename(srclfile, destlfile) | ||||
lfdirstate.remove(os.path.relpath(srclfile, | ||||
repo.root)) | ||||
else: | ||||
util.copyfile(srclfile, destlfile) | ||||
lfdirstate.add(os.path.relpath(destlfile, | ||||
repo.root)) | ||||
lfdirstate.write() | ||||
except util.Abort, e: | ||||
if str(e) != 'no files to copy': | ||||
raise e | ||||
else: | ||||
nolfiles = True | ||||
finally: | ||||
restorematchfn() | ||||
wlock.release() | ||||
if nolfiles and nonormalfiles: | ||||
raise util.Abort(_('no files to copy')) | ||||
return result | ||||
# When the user calls revert, we have to be careful to not revert any changes | ||||
# to other lfiles accidentally. This means we have to keep track of the lfiles | ||||
# that are being reverted so we only pull down the necessary lfiles. | ||||
# | ||||
# Standins are only updated (to match the hash of lfiles) before commits. | ||||
# Update the standins then run the original revert (changing the matcher to hit | ||||
# standins instead of lfiles). Based on the resulting standins update the | ||||
# lfiles. Then return the standins to their proper state | ||||
def override_revert(orig, ui, repo, *pats, **opts): | ||||
# Because we put the standins in a bad state (by updating them) and then | ||||
# return them to a correct state we need to lock to prevent others from | ||||
# changing them in their incorrect state. | ||||
wlock = repo.wlock() | ||||
try: | ||||
lfdirstate = lfutil.openlfdirstate(ui, repo) | ||||
(modified, added, removed, missing, unknown, ignored, clean) = \ | ||||
lfutil.lfdirstate_status(lfdirstate, repo, repo['.'].rev()) | ||||
for lfile in modified: | ||||
lfutil.updatestandin(repo, lfutil.standin(lfile)) | ||||
try: | ||||
ctx = repo[opts.get('rev')] | ||||
oldmatch = None # for the closure | ||||
def override_match(ctxorrepo, pats=[], opts={}, globbed=False, | ||||
default='relpath'): | ||||
|
r15169 | if util.safehasattr(ctxorrepo, 'match'): | ||
|
r15168 | ctx0 = ctxorrepo | ||
else: | ||||
ctx0 = ctxorrepo[None] | ||||
match = oldmatch(ctxorrepo, pats, opts, globbed, default) | ||||
m = copy.copy(match) | ||||
def tostandin(f): | ||||
if lfutil.standin(f) in ctx0 or lfutil.standin(f) in ctx: | ||||
return lfutil.standin(f) | ||||
elif lfutil.standin(f) in repo[None]: | ||||
return None | ||||
return f | ||||
m._files = [tostandin(f) for f in m._files] | ||||
m._files = [f for f in m._files if f is not None] | ||||
m._fmap = set(m._files) | ||||
orig_matchfn = m.matchfn | ||||
def matchfn(f): | ||||
if lfutil.isstandin(f): | ||||
# We need to keep track of what lfiles are being | ||||
# matched so we know which ones to update later | ||||
# (otherwise we revert changes to other lfiles | ||||
# accidentally). This is repo specific, so duckpunch | ||||
# the repo object to keep the list of lfiles for us | ||||
# later. | ||||
if orig_matchfn(lfutil.splitstandin(f)) and \ | ||||
(f in repo[None] or f in ctx): | ||||
lfileslist = getattr(repo, '_lfilestoupdate', []) | ||||
lfileslist.append(lfutil.splitstandin(f)) | ||||
repo._lfilestoupdate = lfileslist | ||||
return True | ||||
else: | ||||
return False | ||||
return orig_matchfn(f) | ||||
m.matchfn = matchfn | ||||
return m | ||||
oldmatch = installmatchfn(override_match) | ||||
try: | ||||
# Mercurial >= 1.9 | ||||
scmutil.match | ||||
matches = override_match(repo[None], pats, opts) | ||||
except ImportError: | ||||
# Mercurial <= 1.8 | ||||
matches = override_match(repo, pats, opts) | ||||
orig(ui, repo, *pats, **opts) | ||||
finally: | ||||
restorematchfn() | ||||
lfileslist = getattr(repo, '_lfilestoupdate', []) | ||||
|
r15170 | lfcommands.updatelfiles(ui, repo, filelist=lfileslist, | ||
printmessage=False) | ||||
|
r15168 | # Empty out the lfiles list so we start fresh next time | ||
repo._lfilestoupdate = [] | ||||
for lfile in modified: | ||||
if lfile in lfileslist: | ||||
if os.path.exists(repo.wjoin(lfutil.standin(lfile))) and lfile\ | ||||
in repo['.']: | ||||
lfutil.writestandin(repo, lfutil.standin(lfile), | ||||
repo['.'][lfile].data().strip(), | ||||
'x' in repo['.'][lfile].flags()) | ||||
lfdirstate = lfutil.openlfdirstate(ui, repo) | ||||
for lfile in added: | ||||
standin = lfutil.standin(lfile) | ||||
if standin not in ctx and (standin in matches or opts.get('all')): | ||||
if lfile in lfdirstate: | ||||
try: | ||||
# Mercurial >= 1.9 | ||||
lfdirstate.drop(lfile) | ||||
except AttributeError: | ||||
# Mercurial <= 1.8 | ||||
lfdirstate.forget(lfile) | ||||
util.unlinkpath(repo.wjoin(standin)) | ||||
lfdirstate.write() | ||||
finally: | ||||
wlock.release() | ||||
def hg_update(orig, repo, node): | ||||
result = orig(repo, node) | ||||
# XXX check if it worked first | ||||
lfcommands.updatelfiles(repo.ui, repo) | ||||
return result | ||||
def hg_clean(orig, repo, node, show_stats=True): | ||||
result = orig(repo, node, show_stats) | ||||
lfcommands.updatelfiles(repo.ui, repo) | ||||
return result | ||||
def hg_merge(orig, repo, node, force=None, remind=True): | ||||
result = orig(repo, node, force, remind) | ||||
lfcommands.updatelfiles(repo.ui, repo) | ||||
return result | ||||
# When we rebase a repository with remotely changed lfiles, we need | ||||
# to take some extra care so that the lfiles are correctly updated | ||||
# in the working copy | ||||
def override_pull(orig, ui, repo, source=None, **opts): | ||||
if opts.get('rebase', False): | ||||
repo._isrebasing = True | ||||
try: | ||||
if opts.get('update'): | ||||
del opts['update'] | ||||
ui.debug('--update and --rebase are not compatible, ignoring ' | ||||
'the update flag\n') | ||||
del opts['rebase'] | ||||
try: | ||||
# Mercurial >= 1.9 | ||||
cmdutil.bailifchanged(repo) | ||||
except AttributeError: | ||||
# Mercurial <= 1.8 | ||||
cmdutil.bail_if_changed(repo) | ||||
revsprepull = len(repo) | ||||
origpostincoming = commands.postincoming | ||||
def _dummy(*args, **kwargs): | ||||
pass | ||||
commands.postincoming = _dummy | ||||
repo.lfpullsource = source | ||||
if not source: | ||||
source = 'default' | ||||
try: | ||||
result = commands.pull(ui, repo, source, **opts) | ||||
finally: | ||||
commands.postincoming = origpostincoming | ||||
revspostpull = len(repo) | ||||
if revspostpull > revsprepull: | ||||
result = result or rebase.rebase(ui, repo) | ||||
finally: | ||||
repo._isrebasing = False | ||||
else: | ||||
repo.lfpullsource = source | ||||
if not source: | ||||
source = 'default' | ||||
result = orig(ui, repo, source, **opts) | ||||
return result | ||||
def override_rebase(orig, ui, repo, **opts): | ||||
repo._isrebasing = True | ||||
try: | ||||
orig(ui, repo, **opts) | ||||
finally: | ||||
repo._isrebasing = False | ||||
def override_archive(orig, repo, dest, node, kind, decode=True, matchfn=None, | ||||
prefix=None, mtime=None, subrepos=None): | ||||
# No need to lock because we are only reading history and lfile caches | ||||
# neither of which are modified | ||||
lfcommands.cachelfiles(repo.ui, repo, node) | ||||
if kind not in archival.archivers: | ||||
raise util.Abort(_("unknown archive type '%s'") % kind) | ||||
ctx = repo[node] | ||||
# In Mercurial <= 1.5 the prefix is passed to the archiver so try that | ||||
# if that doesn't work we are probably in Mercurial >= 1.6 where the | ||||
# prefix is not handled by the archiver | ||||
try: | ||||
archiver = archival.archivers[kind](dest, prefix, mtime or \ | ||||
ctx.date()[0]) | ||||
def write(name, mode, islink, getdata): | ||||
if matchfn and not matchfn(name): | ||||
return | ||||
data = getdata() | ||||
if decode: | ||||
data = repo.wwritedata(name, data) | ||||
archiver.addfile(name, mode, islink, data) | ||||
except TypeError: | ||||
if kind == 'files': | ||||
if prefix: | ||||
raise util.Abort( | ||||
_('cannot give prefix when archiving to files')) | ||||
else: | ||||
prefix = archival.tidyprefix(dest, kind, prefix) | ||||
def write(name, mode, islink, getdata): | ||||
if matchfn and not matchfn(name): | ||||
return | ||||
data = getdata() | ||||
if decode: | ||||
data = repo.wwritedata(name, data) | ||||
archiver.addfile(prefix + name, mode, islink, data) | ||||
archiver = archival.archivers[kind](dest, mtime or ctx.date()[0]) | ||||
if repo.ui.configbool("ui", "archivemeta", True): | ||||
def metadata(): | ||||
base = 'repo: %s\nnode: %s\nbranch: %s\n' % ( | ||||
hex(repo.changelog.node(0)), hex(node), ctx.branch()) | ||||
tags = ''.join('tag: %s\n' % t for t in ctx.tags() | ||||
if repo.tagtype(t) == 'global') | ||||
if not tags: | ||||
repo.ui.pushbuffer() | ||||
opts = {'template': '{latesttag}\n{latesttagdistance}', | ||||
'style': '', 'patch': None, 'git': None} | ||||
cmdutil.show_changeset(repo.ui, repo, opts).show(ctx) | ||||
ltags, dist = repo.ui.popbuffer().split('\n') | ||||
tags = ''.join('latesttag: %s\n' % t for t in ltags.split(':')) | ||||
tags += 'latesttagdistance: %s\n' % dist | ||||
return base + tags | ||||
write('.hg_archival.txt', 0644, False, metadata) | ||||
for f in ctx: | ||||
ff = ctx.flags(f) | ||||
getdata = ctx[f].data | ||||
if lfutil.isstandin(f): | ||||
path = lfutil.findfile(repo, getdata().strip()) | ||||
f = lfutil.splitstandin(f) | ||||
def getdatafn(): | ||||
try: | ||||
fd = open(path, 'rb') | ||||
return fd.read() | ||||
finally: | ||||
fd.close() | ||||
getdata = getdatafn | ||||
write(f, 'x' in ff and 0755 or 0644, 'l' in ff, getdata) | ||||
if subrepos: | ||||
for subpath in ctx.substate: | ||||
sub = ctx.sub(subpath) | ||||
try: | ||||
sub.archive(repo.ui, archiver, prefix) | ||||
except TypeError: | ||||
sub.archive(archiver, prefix) | ||||
archiver.done() | ||||
# If a lfile is modified the change is not reflected in its standin until a | ||||
# commit. cmdutil.bailifchanged raises an exception if the repo has | ||||
# uncommitted changes. Wrap it to also check if lfiles were changed. This is | ||||
# used by bisect and backout. | ||||
def override_bailifchanged(orig, repo): | ||||
orig(repo) | ||||
repo.lfstatus = True | ||||
modified, added, removed, deleted = repo.status()[:4] | ||||
repo.lfstatus = False | ||||
if modified or added or removed or deleted: | ||||
raise util.Abort(_('outstanding uncommitted changes')) | ||||
# Fetch doesn't use cmdutil.bail_if_changed so override it to add the check | ||||
def override_fetch(orig, ui, repo, *pats, **opts): | ||||
repo.lfstatus = True | ||||
modified, added, removed, deleted = repo.status()[:4] | ||||
repo.lfstatus = False | ||||
if modified or added or removed or deleted: | ||||
raise util.Abort(_('outstanding uncommitted changes')) | ||||
return orig(ui, repo, *pats, **opts) | ||||
def override_forget(orig, ui, repo, *pats, **opts): | ||||
installnormalfilesmatchfn(repo[None].manifest()) | ||||
orig(ui, repo, *pats, **opts) | ||||
restorematchfn() | ||||
try: | ||||
# Mercurial >= 1.9 | ||||
m = scmutil.match(repo[None], pats, opts) | ||||
except ImportError: | ||||
# Mercurial <= 1.8 | ||||
m = cmdutil.match(repo, pats, opts) | ||||
try: | ||||
repo.lfstatus = True | ||||
s = repo.status(match=m, clean=True) | ||||
finally: | ||||
repo.lfstatus = False | ||||
forget = sorted(s[0] + s[1] + s[3] + s[6]) | ||||
forget = [f for f in forget if lfutil.standin(f) in repo[None].manifest()] | ||||
for f in forget: | ||||
if lfutil.standin(f) not in repo.dirstate and not \ | ||||
os.path.isdir(m.rel(lfutil.standin(f))): | ||||
ui.warn(_('not removing %s: file is already untracked\n') | ||||
% m.rel(f)) | ||||
for f in forget: | ||||
if ui.verbose or not m.exact(f): | ||||
ui.status(_('removing %s\n') % m.rel(f)) | ||||
# Need to lock because standin files are deleted then removed from the | ||||
# repository and we could race inbetween. | ||||
wlock = repo.wlock() | ||||
try: | ||||
lfdirstate = lfutil.openlfdirstate(ui, repo) | ||||
for f in forget: | ||||
if lfdirstate[f] == 'a': | ||||
lfdirstate.drop(f) | ||||
else: | ||||
lfdirstate.remove(f) | ||||
lfdirstate.write() | ||||
lfutil.repo_remove(repo, [lfutil.standin(f) for f in forget], | ||||
unlink=True) | ||||
finally: | ||||
wlock.release() | ||||
def getoutgoinglfiles(ui, repo, dest=None, **opts): | ||||
dest = ui.expandpath(dest or 'default-push', dest or 'default') | ||||
dest, branches = hg.parseurl(dest, opts.get('branch')) | ||||
revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get('rev')) | ||||
if revs: | ||||
revs = [repo.lookup(rev) for rev in revs] | ||||
# Mercurial <= 1.5 had remoteui in cmdutil, then it moved to hg | ||||
try: | ||||
remoteui = cmdutil.remoteui | ||||
except AttributeError: | ||||
remoteui = hg.remoteui | ||||
try: | ||||
remote = hg.repository(remoteui(repo, opts), dest) | ||||
except error.RepoError: | ||||
return None | ||||
o = lfutil.findoutgoing(repo, remote, False) | ||||
if not o: | ||||
return None | ||||
o = repo.changelog.nodesbetween(o, revs)[0] | ||||
if opts.get('newest_first'): | ||||
o.reverse() | ||||
toupload = set() | ||||
for n in o: | ||||
parents = [p for p in repo.changelog.parents(n) if p != node.nullid] | ||||
ctx = repo[n] | ||||
files = set(ctx.files()) | ||||
if len(parents) == 2: | ||||
mc = ctx.manifest() | ||||
mp1 = ctx.parents()[0].manifest() | ||||
mp2 = ctx.parents()[1].manifest() | ||||
for f in mp1: | ||||
if f not in mc: | ||||
files.add(f) | ||||
for f in mp2: | ||||
if f not in mc: | ||||
files.add(f) | ||||
for f in mc: | ||||
if mc[f] != mp1.get(f, None) or mc[f] != mp2.get(f, None): | ||||
files.add(f) | ||||
toupload = toupload.union(set([f for f in files if lfutil.isstandin(f)\ | ||||
and f in ctx])) | ||||
return toupload | ||||
def override_outgoing(orig, ui, repo, dest=None, **opts): | ||||
orig(ui, repo, dest, **opts) | ||||
if opts.pop('large', None): | ||||
toupload = getoutgoinglfiles(ui, repo, dest, **opts) | ||||
if toupload is None: | ||||
ui.status(_('largefiles: No remote repo\n')) | ||||
else: | ||||
ui.status(_('largefiles to upload:\n')) | ||||
for file in toupload: | ||||
ui.status(lfutil.splitstandin(file) + '\n') | ||||
ui.status('\n') | ||||
def override_summary(orig, ui, repo, *pats, **opts): | ||||
orig(ui, repo, *pats, **opts) | ||||
if opts.pop('large', None): | ||||
toupload = getoutgoinglfiles(ui, repo, None, **opts) | ||||
if toupload is None: | ||||
ui.status(_('largefiles: No remote repo\n')) | ||||
else: | ||||
ui.status(_('largefiles: %d to upload\n') % len(toupload)) | ||||
def override_addremove(orig, ui, repo, *pats, **opts): | ||||
# Check if the parent or child has lfiles if they do don't allow it. If | ||||
# there is a symlink in the manifest then getting the manifest throws an | ||||
# exception catch it and let addremove deal with it. This happens in | ||||
# Mercurial's test test-addremove-symlink | ||||
try: | ||||
manifesttip = set(repo['tip'].manifest()) | ||||
except util.Abort: | ||||
manifesttip = set() | ||||
try: | ||||
manifestworking = set(repo[None].manifest()) | ||||
except util.Abort: | ||||
manifestworking = set() | ||||
# Manifests are only iterable so turn them into sets then union | ||||
for file in manifesttip.union(manifestworking): | ||||
if file.startswith(lfutil.shortname): | ||||
raise util.Abort( | ||||
_('addremove cannot be run on a repo with largefiles')) | ||||
return orig(ui, repo, *pats, **opts) | ||||
# Calling purge with --all will cause the lfiles to be deleted. | ||||
# Override repo.status to prevent this from happening. | ||||
def override_purge(orig, ui, repo, *dirs, **opts): | ||||
oldstatus = repo.status | ||||
def override_status(node1='.', node2=None, match=None, ignored=False, | ||||
clean=False, unknown=False, listsubrepos=False): | ||||
r = oldstatus(node1, node2, match, ignored, clean, unknown, | ||||
listsubrepos) | ||||
lfdirstate = lfutil.openlfdirstate(ui, repo) | ||||
modified, added, removed, deleted, unknown, ignored, clean = r | ||||
unknown = [f for f in unknown if lfdirstate[f] == '?'] | ||||
ignored = [f for f in ignored if lfdirstate[f] == '?'] | ||||
return modified, added, removed, deleted, unknown, ignored, clean | ||||
repo.status = override_status | ||||
orig(ui, repo, *dirs, **opts) | ||||
repo.status = oldstatus | ||||
def override_rollback(orig, ui, repo, **opts): | ||||
result = orig(ui, repo, **opts) | ||||
merge.update(repo, node=None, branchmerge=False, force=True, | ||||
partial=lfutil.isstandin) | ||||
lfdirstate = lfutil.openlfdirstate(ui, repo) | ||||
lfiles = lfutil.listlfiles(repo) | ||||
oldlfiles = lfutil.listlfiles(repo, repo[None].parents()[0].rev()) | ||||
for file in lfiles: | ||||
if file in oldlfiles: | ||||
lfdirstate.normallookup(file) | ||||
else: | ||||
lfdirstate.add(file) | ||||
lfdirstate.write() | ||||
return result | ||||