overrides.py
955 lines
| 36.9 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 | ||||
|
r15305 | from mercurial import hg, commands, util, cmdutil, scmutil, match as match_, \ | ||
node, archival, error, merge | ||||
|
r15168 | from mercurial.i18n import _ | ||
from mercurial.node import hex | ||||
from hgext import rebase | ||||
import lfutil | ||||
import lfcommands | ||||
|
r15792 | # -- Utility functions: commonly/repeatedly needed functionality --------------- | ||
|
r15168 | def installnormalfilesmatchfn(manifest): | ||
'''overrides scmutil.match so that the matcher it returns will ignore all | ||||
largefiles''' | ||||
oldmatch = None # for the closure | ||||
|
r15306 | def override_match(ctx, pats=[], opts={}, globbed=False, | ||
|
r15168 | default='relpath'): | ||
|
r15306 | match = oldmatch(ctx, pats, opts, globbed, default) | ||
|
r15168 | 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): | ||||
|
r15224 | oldmatch = scmutil.match | ||
|
r15168 | setattr(f, 'oldmatch', oldmatch) | ||
|
r15224 | scmutil.match = f | ||
|
r15168 | 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''' | ||||
|
r15224 | scmutil.match = getattr(scmutil.match, 'oldmatch', scmutil.match) | ||
|
r15168 | |||
|
r15792 | def add_largefiles(ui, repo, *pats, **opts): | ||
|
r15168 | large = opts.pop('large', None) | ||
|
r15227 | lfsize = lfutil.getminsize( | ||
ui, lfutil.islfilesrepo(repo), opts.pop('lfsize', None)) | ||||
|
r15168 | |||
lfmatcher = None | ||||
|
r15739 | if lfutil.islfilesrepo(repo): | ||
|
r15229 | lfpats = ui.configlist(lfutil.longname, 'patterns', default=[]) | ||
|
r15168 | if lfpats: | ||
lfmatcher = match_.match(repo.root, '', list(lfpats)) | ||||
lfnames = [] | ||||
|
r15224 | m = scmutil.match(repo[None], pats, opts) | ||
|
r15168 | 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: | ||||
|
r15255 | abovemin = (lfsize and | ||
|
r15369 | os.lstat(repo.wjoin(f)).st_size >= lfsize * 1024 * 1024) | ||
|
r15255 | if large or abovemin or (lfmatcher and lfmatcher(f)): | ||
|
r15168 | lfnames.append(f) | ||
if ui.verbose or not exact: | ||||
ui.status(_('adding %s as a largefile\n') % m.rel(f)) | ||||
bad = [] | ||||
standins = [] | ||||
|
r15252 | # Need to lock, otherwise there could be a race condition between | ||
# when standins are created and added to the repo. | ||||
|
r15168 | 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() | ||||
|
r15255 | bad += [lfutil.splitstandin(f) | ||
for f in lfutil.repo_add(repo, standins) | ||||
if f in m.files()] | ||||
|
r15168 | finally: | ||
wlock.release() | ||||
|
r15792 | return bad | ||
|
r15168 | |||
|
r15792 | def remove_largefiles(ui, repo, *pats, **opts): | ||
|
r15786 | after = opts.get('after') | ||
|
r15168 | if not pats and not after: | ||
raise util.Abort(_('no files specified')) | ||||
|
r15224 | m = scmutil.match(repo[None], pats, opts) | ||
|
r15168 | try: | ||
repo.lfstatus = True | ||||
s = repo.status(match=m, clean=True) | ||||
finally: | ||||
repo.lfstatus = False | ||||
|
r15792 | manifest = repo[None].manifest() | ||
|
r15255 | 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]]] | ||||
|
r15168 | |||
def warn(files, reason): | ||||
for f in files: | ||||
|
r15786 | ui.warn(_('not removing %s: %s (use forget to undo)\n') | ||
|
r15168 | % (m.rel(f), reason)) | ||
|
r15786 | if after: | ||
|
r15168 | remove, forget = deleted, [] | ||
|
r15294 | warn(modified + added + clean, _('file still exists')) | ||
|
r15168 | else: | ||
remove, forget = deleted + clean, [] | ||||
|
r15294 | warn(modified, _('file is modified')) | ||
warn(added, _('file has been marked for add')) | ||||
|
r15168 | |||
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: | ||||
|
r15792 | # If this is being called by addremove, notify the user that we | ||
# are removing the file. | ||||
if getattr(repo, "_isaddremove", False): | ||||
ui.status(_('removing %s\n' % f)) | ||||
if os.path.exists(repo.wjoin(f)): | ||||
os.unlink(repo.wjoin(f)) | ||||
|
r15168 | 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) | ||||
|
r15792 | # If this is being called by addremove, let the original addremove | ||
# function handle this. | ||||
if not getattr(repo, "_isaddremove", False): | ||||
lfutil.repo_remove(repo, remove, unlink=True) | ||||
|
r15168 | finally: | ||
wlock.release() | ||||
|
r15792 | # -- 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 largefiles. Then it makes a new | ||||
# matcher which matches only the normal files and runs the original | ||||
# version of add. | ||||
def override_add(orig, ui, repo, *pats, **opts): | ||||
bad = add_largefiles(ui, repo, *pats, **opts) | ||||
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): | ||||
installnormalfilesmatchfn(repo[None].manifest()) | ||||
orig(ui, repo, *pats, **opts) | ||||
restorematchfn() | ||||
remove_largefiles(ui, repo, *pats, **opts) | ||||
|
r15168 | 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 | ||||
|
r15252 | # Need to lock between the standins getting updated and their | ||
# largefiles getting updated | ||||
|
r15168 | 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) | ||||
|
r15663 | # Before starting the manifest merge, merge.updates will call | ||
# _checkunknown to check if there are any files in the merged-in | ||||
# changeset that collide with unknown files in the working copy. | ||||
# | ||||
# The largefiles are seen as unknown, so this prevents us from merging | ||||
# in a file 'foo' if we already have a largefile with the same name. | ||||
# | ||||
# The overridden function filters the unknown files by removing any | ||||
# largefiles. This makes the merge proceed and we can then handle this | ||||
# case further in the overridden manifestmerge function below. | ||||
def override_checkunknown(origfn, wctx, mctx, folding): | ||||
origunknown = wctx.unknown() | ||||
wctx._unknown = filter(lambda f: lfutil.standin(f) not in wctx, origunknown) | ||||
try: | ||||
return origfn(wctx, mctx, folding) | ||||
finally: | ||||
wctx._unknown = origunknown | ||||
# The manifest merge handles conflicts on the manifest level. We want | ||||
# to handle changes in largefile-ness of files at this level too. | ||||
# | ||||
# The strategy is to run the original manifestmerge and then process | ||||
# the action list it outputs. There are two cases we need to deal with: | ||||
# | ||||
# 1. Normal file in p1, largefile in p2. Here the largefile is | ||||
# detected via its standin file, which will enter the working copy | ||||
# with a "get" action. It is not "merge" since the standin is all | ||||
# Mercurial is concerned with at this level -- the link to the | ||||
# existing normal file is not relevant here. | ||||
# | ||||
# 2. Largefile in p1, normal file in p2. Here we get a "merge" action | ||||
# since the largefile will be present in the working copy and | ||||
# different from the normal file in p2. Mercurial therefore | ||||
# triggers a merge action. | ||||
# | ||||
# In both cases, we prompt the user and emit new actions to either | ||||
# remove the standin (if the normal file was kept) or to remove the | ||||
# normal file and get the standin (if the largefile was kept). The | ||||
# default prompt answer is to use the largefile version since it was | ||||
# presumably changed on purpose. | ||||
# | ||||
# Finally, the merge.applyupdates function will then take care of | ||||
# writing the files into the working copy and lfcommands.updatelfiles | ||||
# will update the largefiles. | ||||
def override_manifestmerge(origfn, repo, p1, p2, pa, overwrite, partial): | ||||
actions = origfn(repo, p1, p2, pa, overwrite, partial) | ||||
processed = [] | ||||
for action in actions: | ||||
if overwrite: | ||||
processed.append(action) | ||||
continue | ||||
f, m = action[:2] | ||||
choices = (_('&Largefile'), _('&Normal file')) | ||||
if m == "g" and lfutil.splitstandin(f) in p1 and f in p2: | ||||
# Case 1: normal file in the working copy, largefile in | ||||
# the second parent | ||||
lfile = lfutil.splitstandin(f) | ||||
standin = f | ||||
msg = _('%s has been turned into a largefile\n' | ||||
'use (l)argefile or keep as (n)ormal file?') % lfile | ||||
if repo.ui.promptchoice(msg, choices, 0) == 0: | ||||
processed.append((lfile, "r")) | ||||
processed.append((standin, "g", p2.flags(standin))) | ||||
else: | ||||
processed.append((standin, "r")) | ||||
elif m == "m" and lfutil.standin(f) in p1 and f in p2: | ||||
# Case 2: largefile in the working copy, normal file in | ||||
# the second parent | ||||
standin = lfutil.standin(f) | ||||
lfile = f | ||||
msg = _('%s has been turned into a normal file\n' | ||||
'keep as (l)argefile or use (n)ormal file?') % lfile | ||||
if repo.ui.promptchoice(msg, choices, 0) == 0: | ||||
processed.append((lfile, "r")) | ||||
else: | ||||
processed.append((standin, "r")) | ||||
processed.append((lfile, "g", p2.flags(lfile))) | ||||
else: | ||||
processed.append(action) | ||||
return processed | ||||
|
r15252 | # Override filemerge to prompt the user about how they wish to merge | ||
# largefiles. This will handle identical edits, and copy/rename + | ||||
# edit without prompting the user. | ||||
|
r15168 | 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 | ||||
|
r15252 | # Copy first changes the matchers to match standins instead of | ||
# largefiles. Then it overrides util.copyfile in that function it | ||||
# checks if the destination largefile already exists. It also keeps a | ||||
# list of copied files so that the largefiles can be copied and the | ||||
# dirstate updated. | ||||
|
r15168 | def override_copy(orig, ui, repo, pats, opts, rename=False): | ||
|
r15252 | # doesn't remove largefile on rename | ||
|
r15168 | 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): | ||||
|
r15224 | path = scmutil.canonpath(repo.root, repo.getcwd(), relpath) | ||
|
r15323 | return os.path.join(repo.wjoin(lfutil.standin(path))) | ||
|
r15168 | |||
|
r15224 | fullpats = scmutil.expandpats(pats) | ||
|
r15168 | dest = fullpats[-1] | ||
if os.path.isdir(dest): | ||||
if not os.path.isdir(makestandin(dest)): | ||||
os.makedirs(makestandin(dest)) | ||||
|
r15254 | # 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 largefiles and run it again. | ||||
|
r15168 | nonormalfiles = False | ||
nolfiles = False | ||||
try: | ||||
|
r15279 | 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 | ||||
|
r15168 | 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: | ||||
|
r15279 | 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() | ||||
|
r15168 | |||
|
r15279 | manifest = repo[None].manifest() | ||
oldmatch = None # for the closure | ||||
|
r15306 | def override_match(ctx, pats=[], opts={}, globbed=False, | ||
|
r15279 | 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) | ||||
|
r15306 | match = oldmatch(ctx, newpats, opts, globbed, default) | ||
|
r15279 | 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 = [] | ||||
|
r15168 | for pat in pats: | ||
|
r15279 | if match_.patkind(pat) is not None: | ||
listpats.append(pat) | ||||
|
r15168 | else: | ||
|
r15279 | listpats.append(makestandin(pat)) | ||
|
r15168 | |||
|
r15279 | try: | ||
origcopyfile = util.copyfile | ||||
copiedfiles = [] | ||||
def override_copyfile(src, dest): | ||||
|
r15598 | if (lfutil.shortname in src and | ||
dest.startswith(repo.wjoin(lfutil.shortname))): | ||||
|
r15279 | 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) | ||||
|
r15168 | |||
|
r15279 | util.copyfile = override_copyfile | ||
result += orig(ui, repo, listpats, opts, rename) | ||||
finally: | ||||
util.copyfile = origcopyfile | ||||
|
r15168 | |||
|
r15279 | lfdirstate = lfutil.openlfdirstate(ui, repo) | ||
for (src, dest) in copiedfiles: | ||||
|
r15598 | if (lfutil.shortname in src and | ||
dest.startswith(repo.wjoin(lfutil.shortname))): | ||||
srclfile = src.replace(repo.wjoin(lfutil.standin('')), '') | ||||
destlfile = dest.replace(repo.wjoin(lfutil.standin('')), '') | ||||
|
r15279 | destlfiledir = os.path.dirname(destlfile) or '.' | ||
if not os.path.isdir(destlfiledir): | ||||
os.makedirs(destlfiledir) | ||||
if rename: | ||||
|
r15598 | os.rename(repo.wjoin(srclfile), repo.wjoin(destlfile)) | ||
lfdirstate.remove(srclfile) | ||||
|
r15279 | else: | ||
util.copyfile(srclfile, destlfile) | ||||
|
r15598 | lfdirstate.add(destlfile) | ||
|
r15279 | lfdirstate.write() | ||
except util.Abort, e: | ||||
if str(e) != 'no files to copy': | ||||
raise e | ||||
else: | ||||
nolfiles = True | ||||
|
r15168 | finally: | ||
restorematchfn() | ||||
wlock.release() | ||||
if nolfiles and nonormalfiles: | ||||
raise util.Abort(_('no files to copy')) | ||||
return result | ||||
|
r15254 | # When the user calls revert, we have to be careful to not revert any | ||
# changes to other largefiles accidentally. This means we have to keep | ||||
# track of the largefiles that are being reverted so we only pull down | ||||
# the necessary largefiles. | ||||
|
r15168 | # | ||
|
r15254 | # Standins are only updated (to match the hash of largefiles) before | ||
# commits. Update the standins then run the original revert, changing | ||||
# the matcher to hit standins instead of largefiles. Based on the | ||||
# resulting standins update the largefiles. Then return the standins | ||||
# to their proper state | ||||
|
r15168 | def override_revert(orig, ui, repo, *pats, **opts): | ||
|
r15254 | # 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. | ||||
|
r15168 | 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 | ||||
|
r15306 | def override_match(ctx, pats=[], opts={}, globbed=False, | ||
|
r15168 | default='relpath'): | ||
|
r15306 | match = oldmatch(ctx, pats, opts, globbed, default) | ||
|
r15168 | m = copy.copy(match) | ||
def tostandin(f): | ||||
|
r15306 | if lfutil.standin(f) in ctx or lfutil.standin(f) in ctx: | ||
|
r15168 | 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): | ||||
|
r15254 | # We need to keep track of what largefiles are being | ||
# matched so we know which ones to update later -- | ||||
# otherwise we accidentally revert changes to other | ||||
# largefiles. This is repo-specific, so duckpunch the | ||||
# repo object to keep the list of largefiles for us | ||||
|
r15168 | # 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) | ||||
|
r15224 | scmutil.match | ||
matches = override_match(repo[None], pats, opts) | ||||
|
r15168 | orig(ui, repo, *pats, **opts) | ||
finally: | ||||
restorematchfn() | ||||
lfileslist = getattr(repo, '_lfilestoupdate', []) | ||||
|
r15170 | lfcommands.updatelfiles(ui, repo, filelist=lfileslist, | ||
printmessage=False) | ||||
|
r15254 | |||
# empty out the largefiles list so we start fresh next time | ||||
|
r15168 | 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: | ||||
|
r15224 | lfdirstate.drop(lfile) | ||
|
r15168 | util.unlinkpath(repo.wjoin(standin)) | ||
lfdirstate.write() | ||||
finally: | ||||
wlock.release() | ||||
def hg_update(orig, repo, node): | ||||
result = orig(repo, node) | ||||
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): | ||||
|
r15860 | # Mark the repo as being in the middle of a merge, so that | ||
# updatelfiles() will know that it needs to trust the standins in | ||||
# the working copy, not in the standins in the current node | ||||
repo._ismerging = True | ||||
try: | ||||
result = orig(repo, node, force, remind) | ||||
lfcommands.updatelfiles(repo.ui, repo) | ||||
finally: | ||||
repo._ismerging = False | ||||
|
r15168 | return result | ||
|
r15254 | # When we rebase a repository with remotely changed largefiles, we need to | ||
# take some extra care so that the largefiles are correctly updated in the | ||||
# working copy | ||||
|
r15168 | 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'] | ||||
|
r15224 | cmdutil.bailifchanged(repo) | ||
|
r15168 | 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) | ||||
|
r15916 | # If we do not have the new largefiles for any new heads we pulled, we | ||
# will run into a problem later if we try to merge or rebase with one of | ||||
# these heads, so cache the largefiles now direclty into the system | ||||
# cache. | ||||
ui.status(_("caching new largefiles\n")) | ||||
numcached = 0 | ||||
branches = repo.branchmap() | ||||
for branch in branches: | ||||
heads = repo.branchheads(branch) | ||||
for head in heads: | ||||
(cached, missing) = lfcommands.cachelfiles(ui, repo, head) | ||||
numcached += len(cached) | ||||
ui.status(_("%d largefiles cached\n" % numcached)) | ||||
|
r15168 | 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): | ||||
|
r15254 | # No need to lock because we are only reading history and | ||
# largefile caches, neither of which are modified. | ||||
|
r15168 | lfcommands.cachelfiles(repo.ui, repo, node) | ||
if kind not in archival.archivers: | ||||
raise util.Abort(_("unknown archive type '%s'") % kind) | ||||
ctx = repo[node] | ||||
|
r15224 | if kind == 'files': | ||
if prefix: | ||||
raise util.Abort( | ||||
_('cannot give prefix when archiving to files')) | ||||
else: | ||||
prefix = archival.tidyprefix(dest, kind, prefix) | ||||
|
r15168 | |||
|
r15224 | 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) | ||||
|
r15168 | |||
|
r15224 | archiver = archival.archivers[kind](dest, mtime or ctx.date()[0]) | ||
|
r15168 | |||
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()) | ||||
|
r15914 | if path is None: | ||
raise util.Abort( | ||||
_('largefile %s not found in repo store or system cache') | ||||
% lfutil.splitstandin(f)) | ||||
|
r15168 | f = lfutil.splitstandin(f) | ||
def getdatafn(): | ||||
|
r15576 | fd = None | ||
|
r15168 | try: | ||
fd = open(path, 'rb') | ||||
return fd.read() | ||||
finally: | ||||
|
r15576 | if fd: | ||
fd.close() | ||||
|
r15168 | |||
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) | ||||
|
r15626 | sub.archive(repo.ui, archiver, prefix) | ||
|
r15168 | |||
archiver.done() | ||||
|
r15254 | # If a largefile 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 | ||||
# largefiles were changed. This is used by bisect and backout. | ||||
|
r15168 | 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() | ||||
|
r15224 | m = scmutil.match(repo[None], pats, opts) | ||
|
r15168 | |||
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] | ||||
|
r15224 | remoteui = hg.remoteui | ||
|
r15168 | |||
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) | ||||
|
r15255 | toupload = toupload.union( | ||
set([f for f in files if lfutil.isstandin(f) and f in ctx])) | ||||
|
r15168 | 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): | ||||
|
r15787 | try: | ||
repo.lfstatus = True | ||||
orig(ui, repo, *pats, **opts) | ||||
finally: | ||||
repo.lfstatus = False | ||||
|
r15168 | |||
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): | ||||
|
r15792 | # Get the list of missing largefiles so we can remove them | ||
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 | ||||
|
r15168 | |||
|
r15792 | # Call into the normal remove code, but the removing of the standin, we want | ||
# to have handled by original addremove. Monkey patching here makes sure | ||||
# we don't remove the standin in the largefiles code, preventing a very | ||||
# confused state later. | ||||
repo._isaddremove = True | ||||
remove_largefiles(ui, repo, *missing, **opts) | ||||
repo._isaddremove = False | ||||
# Call into the normal add code, and any files that *should* be added as | ||||
# largefiles will be | ||||
add_largefiles(ui, repo, *pats, **opts) | ||||
# Now that we've handled largefiles, hand off to the original addremove | ||||
# function to take care of the rest. Make sure it doesn't do anything with | ||||
# largefiles by installing a matcher that will ignore them. | ||||
installnormalfilesmatchfn(repo[None].manifest()) | ||||
result = orig(ui, repo, *pats, **opts) | ||||
restorematchfn() | ||||
return result | ||||
|
r15168 | |||
|
r15254 | # Calling purge with --all will cause the largefiles to be deleted. | ||
|
r15168 | # 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) | ||||
|
r15794 | wlock = repo.wlock() | ||
try: | ||||
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() | ||||
finally: | ||||
wlock.release() | ||||
|
r15168 | return result | ||
|
r15383 | |||
def override_transplant(orig, ui, repo, *revs, **opts): | ||||
result = orig(ui, repo, *revs, **opts) | ||||
lfcommands.updatelfiles(repo.ui, repo) | ||||
return result | ||||