overrides.py
1196 lines
| 44.8 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_, \ | ||
|
r20442 | node, archival, error, merge, discovery, pathutil, revset | ||
|
r15168 | from mercurial.i18n import _ | ||
from mercurial.node import hex | ||||
from hgext import rebase | ||||
import lfutil | ||||
import lfcommands | ||||
|
r18974 | import basestore | ||
|
r15168 | |||
|
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 | ||||
|
r16247 | def overridematch(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) | ||||
|
r18813 | m._always = False | ||
|
r16247 | origmatchfn = m.matchfn | ||
m.matchfn = lambda f: notlfile(f) and origmatchfn(f) or None | ||||
|
r15168 | return m | ||
|
r16247 | oldmatch = installmatchfn(overridematch) | ||
|
r15168 | |||
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 | |||
|
r16247 | def addlargefiles(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 | ||||
|
r17232 | if (exact or not exists) and not lfutil.isstandin(f): | ||
|
r17231 | wfile = repo.wjoin(f) | ||
# In case the file was removed previously, but not committed | ||||
# (issue3507) | ||||
if not os.path.exists(wfile): | ||||
continue | ||||
|
r15255 | abovemin = (lfsize and | ||
|
r17231 | os.lstat(wfile).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) | ||
|
r18154 | for f in repo[None].add(standins) | ||
|
r15255 | if f in m.files()] | ||
|
r15168 | finally: | ||
wlock.release() | ||||
|
r15792 | return bad | ||
|
r15168 | |||
|
r16247 | def removelargefiles(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 | |||
|
r18066 | def warn(files, msg): | ||
|
r15168 | for f in files: | ||
|
r18066 | ui.warn(msg % m.rel(f)) | ||
|
r17576 | return int(len(files) > 0) | ||
result = 0 | ||||
|
r15168 | |||
|
r15786 | if after: | ||
|
r15168 | remove, forget = deleted, [] | ||
|
r18066 | result = warn(modified + added + clean, | ||
_('not removing %s: file still exists\n')) | ||||
|
r15168 | else: | ||
remove, forget = deleted + clean, [] | ||||
|
r18066 | result = warn(modified, _('not removing %s: file is modified (use -f' | ||
' to force removal)\n')) | ||||
result = warn(added, _('not removing %s: file has been marked for add' | ||||
' (use forget to undo)\n')) or result | ||||
|
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 | ||||
|
r17424 | # repository and we could race in-between. | ||
|
r15168 | 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): | ||||
|
r16231 | ui.status(_('removing %s\n') % f) | ||
|
r18386 | util.unlinkpath(repo.wjoin(f), ignoremissing=True) | ||
|
r15168 | lfdirstate.remove(f) | ||
lfdirstate.write() | ||||
forget = [lfutil.standin(f) for f in forget] | ||||
remove = [lfutil.standin(f) for f in remove] | ||||
|
r18154 | repo[None].forget(forget) | ||
|
r15792 | # If this is being called by addremove, let the original addremove | ||
# function handle this. | ||||
if not getattr(repo, "_isaddremove", False): | ||||
|
r18153 | for f in remove: | ||
util.unlinkpath(repo.wjoin(f), ignoremissing=True) | ||||
repo[None].forget(remove) | ||||
|
r15168 | finally: | ||
wlock.release() | ||||
|
r17576 | return result | ||
|
r16449 | # For overriding mercurial.hgweb.webcommands so that largefiles will | ||
# appear at their right place in the manifests. | ||||
def decodepath(orig, path): | ||||
return lfutil.splitstandin(path) or path | ||||
|
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. | ||||
|
r16247 | def overrideadd(orig, ui, repo, *pats, **opts): | ||
|
r15944 | normal = opts.pop('normal') | ||
if normal: | ||||
if opts.get('large'): | ||||
raise util.Abort(_('--normal cannot be used with --large')) | ||||
return orig(ui, repo, *pats, **opts) | ||||
|
r16247 | bad = addlargefiles(ui, repo, *pats, **opts) | ||
|
r15792 | installnormalfilesmatchfn(repo[None].manifest()) | ||
result = orig(ui, repo, *pats, **opts) | ||||
restorematchfn() | ||||
return (result == 1 or bad) and 1 or 0 | ||||
|
r16247 | def overrideremove(orig, ui, repo, *pats, **opts): | ||
|
r15792 | installnormalfilesmatchfn(repo[None].manifest()) | ||
|
r17576 | result = orig(ui, repo, *pats, **opts) | ||
|
r15792 | restorematchfn() | ||
|
r17576 | return removelargefiles(ui, repo, *pats, **opts) or result | ||
|
r15792 | |||
|
r16515 | def overridestatusfn(orig, repo, rev2, **opts): | ||
try: | ||||
repo._repo.lfstatus = True | ||||
return orig(repo, rev2, **opts) | ||||
finally: | ||||
repo._repo.lfstatus = False | ||||
|
r16247 | def overridestatus(orig, ui, repo, *pats, **opts): | ||
|
r15168 | try: | ||
repo.lfstatus = True | ||||
return orig(ui, repo, *pats, **opts) | ||||
finally: | ||||
repo.lfstatus = False | ||||
|
r16516 | def overridedirty(orig, repo, ignoreupdate=False): | ||
try: | ||||
repo._repo.lfstatus = True | ||||
return orig(repo, ignoreupdate) | ||||
finally: | ||||
repo._repo.lfstatus = False | ||||
|
r16247 | def overridelog(orig, ui, repo, *pats, **opts): | ||
|
r18341 | def overridematch(ctx, pats=[], opts={}, globbed=False, | ||
default='relpath'): | ||||
"""Matcher that merges root directory with .hglf, suitable for log. | ||||
It is still possible to match .hglf directly. | ||||
For any listed files run log on the standin too. | ||||
matchfn tries both the given filename and with .hglf stripped. | ||||
""" | ||||
match = oldmatch(ctx, pats, opts, globbed, default) | ||||
m = copy.copy(match) | ||||
|
r19472 | for i in range(0, len(m._files)): | ||
standin = lfutil.standin(m._files[i]) | ||||
if standin in repo[ctx.node()]: | ||||
m._files[i] = standin | ||||
|
r18341 | m._fmap = set(m._files) | ||
|
r18813 | m._always = False | ||
|
r18341 | origmatchfn = m.matchfn | ||
def lfmatchfn(f): | ||||
lf = lfutil.splitstandin(f) | ||||
if lf is not None and origmatchfn(lf): | ||||
return True | ||||
r = origmatchfn(f) | ||||
return r | ||||
m.matchfn = lfmatchfn | ||||
return m | ||||
oldmatch = installmatchfn(overridematch) | ||||
|
r15168 | try: | ||
repo.lfstatus = True | ||||
|
r17577 | return orig(ui, repo, *pats, **opts) | ||
|
r15168 | finally: | ||
repo.lfstatus = False | ||||
|
r18341 | restorematchfn() | ||
|
r15168 | |||
|
r16247 | def overrideverify(orig, ui, repo, *pats, **opts): | ||
|
r15168 | large = opts.pop('large', False) | ||
all = opts.pop('lfa', False) | ||||
contents = opts.pop('lfc', False) | ||||
result = orig(ui, repo, *pats, **opts) | ||||
|
r18547 | if large or all or contents: | ||
|
r15168 | result = result or lfcommands.verifylfiles(ui, repo, all, contents) | ||
return result | ||||
|
r18144 | def overridedebugstate(orig, ui, repo, *pats, **opts): | ||
large = opts.pop('large', False) | ||||
if large: | ||||
lfcommands.debugdirstate(ui, repo) | ||||
else: | ||||
orig(ui, repo, *pats, **opts) | ||||
|
r15168 | # Override needs to refresh standins so that update's normal merge | ||
# will go through properly. Then the other update hook (overriding repo.update) | ||||
|
r17424 | # will get the new files. Filemerge is also overridden so that the merge | ||
|
r15168 | # will merge standins correctly. | ||
|
r16247 | def overrideupdate(orig, ui, repo, *pats, **opts): | ||
|
r15168 | 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: | ||||
|
r19805 | raise util.Abort(_('uncommitted changes')) | ||
|
r15168 | # 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. | ||||
|
r16247 | def overridecheckunknownfile(origfn, repo, wctx, mctx, f): | ||
|
r19161 | if lfutil.standin(repo.dirstate.normalize(f)) in wctx: | ||
|
r16093 | return False | ||
return origfn(repo, wctx, mctx, f) | ||||
|
r15663 | |||
# 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. | ||||
|
r20638 | def overridecalculateupdates(origfn, repo, p1, p2, pa, branchmerge, force, | ||
partial, acceptremote=False): | ||||
|
r18605 | overwrite = force and not branchmerge | ||
|
r18778 | actions = origfn(repo, p1, p2, pa, branchmerge, force, partial, | ||
acceptremote) | ||||
|
r19952 | |||
if overwrite: | ||||
return actions | ||||
|
r19954 | removes = set(a[0] for a in actions if a[1] == 'r') | ||
|
r15663 | processed = [] | ||
for action in actions: | ||||
|
r18541 | f, m, args, msg = action | ||
|
r15663 | |||
|
r20148 | splitstandin = f and lfutil.splitstandin(f) | ||
|
r18784 | if (m == "g" and splitstandin is not None and | ||
|
r19954 | splitstandin in p1 and splitstandin not in removes): | ||
|
r15663 | # Case 1: normal file in the working copy, largefile in | ||
# the second parent | ||||
|
r18784 | lfile = splitstandin | ||
|
r15663 | standin = f | ||
|
r19967 | msg = _('remote turned local normal file %s into a largefile\n' | ||
'use (l)argefile or keep (n)ormal file?' | ||||
|
r19226 | '$$ &Largefile $$ &Normal file') % lfile | ||
if repo.ui.promptchoice(msg, 0) == 0: | ||||
|
r18541 | processed.append((lfile, "r", None, msg)) | ||
processed.append((standin, "g", (p2.flags(standin),), msg)) | ||||
|
r15663 | else: | ||
|
r18541 | processed.append((standin, "r", None, msg)) | ||
|
r19954 | elif (m == "g" and | ||
lfutil.standin(f) in p1 and lfutil.standin(f) not in removes): | ||||
|
r15663 | # Case 2: largefile in the working copy, normal file in | ||
# the second parent | ||||
standin = lfutil.standin(f) | ||||
lfile = f | ||||
|
r19967 | msg = _('remote turned local largefile %s into a normal file\n' | ||
'keep (l)argefile or use (n)ormal file?' | ||||
|
r19226 | '$$ &Largefile $$ &Normal file') % lfile | ||
if repo.ui.promptchoice(msg, 0) == 0: | ||||
|
r18541 | processed.append((lfile, "r", None, msg)) | ||
|
r15663 | else: | ||
|
r18541 | processed.append((standin, "r", None, msg)) | ||
processed.append((lfile, "g", (p2.flags(lfile),), msg)) | ||||
|
r15663 | else: | ||
processed.append(action) | ||||
return processed | ||||
|
r15252 | # Override filemerge to prompt the user about how they wish to merge | ||
|
r20295 | # largefiles. This will handle identical edits without prompting the user. | ||
|
r16247 | def overridefilemerge(origfn, repo, mynode, orig, fcd, fco, fca): | ||
|
r15168 | if not lfutil.isstandin(orig): | ||
|
r20298 | return origfn(repo, mynode, orig, fcd, fco, fca) | ||
|
r20994 | ahash = fca.data().strip().lower() | ||
dhash = fcd.data().strip().lower() | ||||
ohash = fco.data().strip().lower() | ||||
if (ohash != ahash and | ||||
ohash != dhash and | ||||
(dhash == ahash or | ||||
repo.ui.promptchoice( | ||||
_('largefile %s has a merge conflict\nancestor was %s\n' | ||||
'keep (l)ocal %s or\ntake (o)ther %s?' | ||||
'$$ &Local $$ &Other') % | ||||
(lfutil.splitstandin(orig), ahash, dhash, ohash), | ||||
0) == 1)): | ||||
|
r20298 | repo.wwrite(fcd.path(), fco.data(), fco.flags()) | ||
return 0 | ||||
|
r15168 | |||
|
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. | ||||
|
r16247 | def overridecopy(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): | ||||
|
r20033 | path = pathutil.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: | ||||
|
r17263 | if str(e) != _('no files to copy'): | ||
|
r15279 | 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: | ||
|
r16248 | # 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. | ||||
|
r15279 | wlock = repo.wlock() | ||
|
r15168 | |||
|
r15279 | manifest = repo[None].manifest() | ||
oldmatch = None # for the closure | ||||
|
r16247 | def overridematch(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) | ||||
|
r18813 | m._always = False | ||
|
r16247 | origmatchfn = m.matchfn | ||
|
r15279 | m.matchfn = lambda f: (lfutil.isstandin(f) and | ||
|
r16075 | (f in manifest) and | ||
|
r16247 | origmatchfn(lfutil.splitstandin(f)) or | ||
|
r15279 | None) | ||
return m | ||||
|
r16247 | oldmatch = installmatchfn(overridematch) | ||
|
r15279 | 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 = [] | ||||
|
r16247 | def overridecopyfile(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 | |||
|
r16247 | util.copyfile = overridecopyfile | ||
|
r15279 | 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('')), '') | ||||
|
r17245 | destlfiledir = os.path.dirname(repo.wjoin(destlfile)) or '.' | ||
|
r15279 | 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: | ||
|
r17245 | util.copyfile(repo.wjoin(srclfile), | ||
repo.wjoin(destlfile)) | ||||
|
r15598 | lfdirstate.add(destlfile) | ||
|
r15279 | lfdirstate.write() | ||
except util.Abort, e: | ||||
|
r17263 | if str(e) != _('no files to copy'): | ||
|
r15279 | 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 | ||||
|
r16247 | def overriderevert(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) = \ | ||||
|
r16247 | lfutil.lfdirstatestatus(lfdirstate, repo, repo['.'].rev()) | ||
|
r18140 | lfdirstate.write() | ||
|
r15168 | for lfile in modified: | ||
lfutil.updatestandin(repo, lfutil.standin(lfile)) | ||||
|
r15983 | for lfile in missing: | ||
|
r16638 | if (os.path.exists(repo.wjoin(lfutil.standin(lfile)))): | ||
os.unlink(repo.wjoin(lfutil.standin(lfile))) | ||||
|
r15168 | |||
try: | ||||
|
r17268 | ctx = scmutil.revsingle(repo, opts.get('rev')) | ||
|
r15168 | oldmatch = None # for the closure | ||
|
r16247 | def overridematch(ctx, pats=[], opts={}, globbed=False, | ||
|
r15168 | default='relpath'): | ||
|
r15306 | match = oldmatch(ctx, pats, opts, globbed, default) | ||
|
r15168 | m = copy.copy(match) | ||
def tostandin(f): | ||||
|
r16074 | if 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) | ||||
|
r18813 | m._always = False | ||
|
r16247 | origmatchfn = m.matchfn | ||
|
r15168 | 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. | ||
|
r16247 | if origmatchfn(lfutil.splitstandin(f)) and \ | ||
|
r15168 | (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 | ||||
|
r16247 | return origmatchfn(f) | ||
|
r15168 | m.matchfn = matchfn | ||
return m | ||||
|
r16247 | oldmatch = installmatchfn(overridematch) | ||
|
r15224 | scmutil.match | ||
|
r16247 | matches = overridematch(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() | ||||
|
r18459 | def hgupdaterepo(orig, repo, node, overwrite): | ||
if not overwrite: | ||||
# Only call updatelfiles on the standins that have changed to save time | ||||
oldstandins = lfutil.getstandinsstate(repo) | ||||
|
r15168 | |||
|
r18459 | result = orig(repo, node, overwrite) | ||
filelist = None | ||||
if not overwrite: | ||||
newstandins = lfutil.getstandinsstate(repo) | ||||
filelist = lfutil.getlfilestoupdate(oldstandins, newstandins) | ||||
lfcommands.updatelfiles(repo.ui, repo, filelist=filelist) | ||||
|
r15168 | return result | ||
|
r16247 | def hgmerge(orig, repo, node, force=None, remind=True): | ||
|
r18728 | result = orig(repo, node, force, remind) | ||
lfcommands.updatelfiles(repo.ui, repo) | ||||
|
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 | ||||
|
r16247 | def overridepull(orig, ui, repo, source=None, **opts): | ||
|
r16692 | revsprepull = len(repo) | ||
|
r18977 | if not source: | ||
source = 'default' | ||||
repo.lfpullsource = source | ||||
|
r15168 | if opts.get('rebase', False): | ||
repo._isrebasing = True | ||||
try: | ||||
if opts.get('update'): | ||||
|
r17299 | del opts['update'] | ||
ui.debug('--update and --rebase are not compatible, ignoring ' | ||||
'the update flag\n') | ||||
|
r15168 | del opts['rebase'] | ||
origpostincoming = commands.postincoming | ||||
def _dummy(*args, **kwargs): | ||||
pass | ||||
commands.postincoming = _dummy | ||||
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: | ||||
result = orig(ui, repo, source, **opts) | ||||
|
r18977 | revspostpull = len(repo) | ||
|
r18981 | lfrevs = opts.get('lfrev', []) | ||
|
r16692 | if opts.get('all_largefiles'): | ||
|
r18981 | lfrevs.append('pulled()') | ||
|
r18978 | if lfrevs and revspostpull > revsprepull: | ||
numcached = 0 | ||||
|
r18979 | repo.firstpulled = revsprepull # for pulled() revset expression | ||
try: | ||||
for rev in scmutil.revrange(repo, lfrevs): | ||||
ui.note(_('pulling largefiles for revision %s\n') % rev) | ||||
(cached, missing) = lfcommands.cachelfiles(ui, repo, rev) | ||||
numcached += len(cached) | ||||
finally: | ||||
del repo.firstpulled | ||||
|
r18978 | ui.status(_("%d largefiles cached\n") % numcached) | ||
|
r15168 | return result | ||
|
r18979 | def pulledrevsetsymbol(repo, subset, x): | ||
"""``pulled()`` | ||||
Changesets that just has been pulled. | ||||
Only available with largefiles from pull --lfrev expressions. | ||||
.. container:: verbose | ||||
Some examples: | ||||
- pull largefiles for all new changesets:: | ||||
hg pull -lfrev "pulled()" | ||||
- pull largefiles for all new branch heads:: | ||||
hg pull -lfrev "head(pulled()) and not closed()" | ||||
""" | ||||
try: | ||||
firstpulled = repo.firstpulled | ||||
except AttributeError: | ||||
raise util.Abort(_("pulled() only available in --lfrev")) | ||||
|
r20442 | return revset.baseset([r for r in subset if r >= firstpulled]) | ||
|
r18979 | |||
|
r16644 | def overrideclone(orig, ui, source, dest=None, **opts): | ||
|
r17600 | d = dest | ||
if d is None: | ||||
d = hg.defaultdest(source) | ||||
if opts.get('all_largefiles') and not hg.islocal(d): | ||||
|
r16723 | raise util.Abort(_( | ||
'--all-largefiles is incompatible with non-local destination %s' % | ||||
|
r17600 | d)) | ||
|
r17601 | |||
return orig(ui, source, dest, **opts) | ||||
def hgclone(orig, ui, opts, *args, **kwargs): | ||||
result = orig(ui, opts, *args, **kwargs) | ||||
|
r17824 | if result is not None: | ||
|
r16644 | sourcerepo, destrepo = result | ||
|
r17599 | repo = destrepo.local() | ||
# Caching is implicitly limited to 'rev' option, since the dest repo was | ||||
|
r17824 | # truncated at that point. The user may expect a download count with | ||
# this option, so attempt whether or not this is a largefile repo. | ||||
if opts.get('all_largefiles'): | ||||
success, missing = lfcommands.downloadlfiles(ui, repo, None) | ||||
|
r17601 | |||
|
r17824 | if missing != 0: | ||
return None | ||||
|
r17601 | |||
return result | ||||
|
r16644 | |||
|
r16247 | def overriderebase(orig, ui, repo, **opts): | ||
|
r15168 | repo._isrebasing = True | ||
try: | ||||
|
r17578 | return orig(ui, repo, **opts) | ||
|
r15168 | finally: | ||
repo._isrebasing = False | ||||
|
r16247 | def overridearchive(orig, repo, dest, node, kind, decode=True, matchfn=None, | ||
|
r15168 | 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: | ||||
|
r18364 | for subpath in sorted(ctx.substate): | ||
|
r15168 | sub = ctx.sub(subpath) | ||
|
r17108 | submatch = match_.narrowmatcher(subpath, matchfn) | ||
sub.archive(repo.ui, archiver, prefix, submatch) | ||||
|
r15168 | |||
archiver.done() | ||||
|
r17108 | def hgsubrepoarchive(orig, repo, ui, archiver, prefix, match=None): | ||
|
r17695 | repo._get(repo._state + ('hg',)) | ||
|
r16578 | rev = repo._state[1] | ||
ctx = repo._repo[rev] | ||||
lfcommands.cachelfiles(ui, repo._repo, ctx.node()) | ||||
def write(name, mode, islink, getdata): | ||||
|
r17108 | # At this point, the standin has been replaced with the largefile name, | ||
# so the normal matcher works here without the lfutil variants. | ||||
if match and not match(f): | ||||
return | ||||
|
r16578 | data = getdata() | ||
archiver.addfile(prefix + repo._path + '/' + name, mode, islink, data) | ||||
for f in ctx: | ||||
ff = ctx.flags(f) | ||||
getdata = ctx[f].data | ||||
if lfutil.isstandin(f): | ||||
path = lfutil.findfile(repo._repo, getdata().strip()) | ||||
if path is None: | ||||
raise util.Abort( | ||||
_('largefile %s not found in repo store or system cache') | ||||
% lfutil.splitstandin(f)) | ||||
f = lfutil.splitstandin(f) | ||||
def getdatafn(): | ||||
fd = None | ||||
try: | ||||
fd = open(os.path.join(prefix, path), 'rb') | ||||
return fd.read() | ||||
finally: | ||||
if fd: | ||||
fd.close() | ||||
getdata = getdatafn | ||||
write(f, 'x' in ff and 0755 or 0644, 'l' in ff, getdata) | ||||
|
r18364 | for subpath in sorted(ctx.substate): | ||
|
r16578 | sub = ctx.sub(subpath) | ||
|
r17108 | submatch = match_.narrowmatcher(subpath, match) | ||
sub.archive(ui, archiver, os.path.join(prefix, repo._path) + '/', | ||||
submatch) | ||||
|
r16578 | |||
|
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. | ||||
|
r16247 | def overridebailifchanged(orig, repo): | ||
|
r15168 | orig(repo) | ||
repo.lfstatus = True | ||||
modified, added, removed, deleted = repo.status()[:4] | ||||
repo.lfstatus = False | ||||
if modified or added or removed or deleted: | ||||
|
r19805 | raise util.Abort(_('uncommitted changes')) | ||
|
r15168 | |||
|
r16247 | # Fetch doesn't use cmdutil.bailifchanged so override it to add the check | ||
def overridefetch(orig, ui, repo, *pats, **opts): | ||||
|
r15168 | repo.lfstatus = True | ||
modified, added, removed, deleted = repo.status()[:4] | ||||
repo.lfstatus = False | ||||
if modified or added or removed or deleted: | ||||
|
r19805 | raise util.Abort(_('uncommitted changes')) | ||
|
r15168 | return orig(ui, repo, *pats, **opts) | ||
|
r16247 | def overrideforget(orig, ui, repo, *pats, **opts): | ||
|
r15168 | installnormalfilesmatchfn(repo[None].manifest()) | ||
|
r17579 | result = orig(ui, repo, *pats, **opts) | ||
|
r15168 | 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)) | ||||
|
r17579 | result = 1 | ||
|
r15168 | |||
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 | ||||
|
r17424 | # repository and we could race in-between. | ||
|
r15168 | 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() | ||||
|
r18153 | standins = [lfutil.standin(f) for f in forget] | ||
for f in standins: | ||||
util.unlinkpath(repo.wjoin(f), ignoremissing=True) | ||||
repo[None].forget(standins) | ||||
|
r15168 | finally: | ||
wlock.release() | ||||
|
r17579 | return result | ||
|
r15168 | 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: | ||||
|
r17271 | revs = [repo.lookup(rev) for rev in scmutil.revrange(repo, revs)] | ||
|
r15168 | |||
try: | ||||
|
r17276 | remote = hg.peer(repo, opts, dest) | ||
|
r15168 | except error.RepoError: | ||
return None | ||||
|
r18152 | outgoing = discovery.findcommonoutgoing(repo, remote.peer(), force=False) | ||
if not outgoing.missing: | ||||
return outgoing.missing | ||||
o = repo.changelog.nodesbetween(outgoing.missing, revs)[0] | ||||
|
r15168 | 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])) | ||||
|
r18368 | return sorted(toupload) | ||
|
r15168 | |||
|
r16247 | def overrideoutgoing(orig, ui, repo, dest=None, **opts): | ||
|
r17575 | result = orig(ui, repo, dest, **opts) | ||
|
r15168 | |||
if opts.pop('large', None): | ||||
toupload = getoutgoinglfiles(ui, repo, dest, **opts) | ||||
if toupload is None: | ||||
ui.status(_('largefiles: No remote repo\n')) | ||||
|
r17835 | elif not toupload: | ||
ui.status(_('largefiles: no files to upload\n')) | ||||
|
r15168 | else: | ||
ui.status(_('largefiles to upload:\n')) | ||||
for file in toupload: | ||||
ui.status(lfutil.splitstandin(file) + '\n') | ||||
ui.status('\n') | ||||
|
r17575 | return result | ||
|
r16247 | def overridesummary(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: | ||||
|
r17892 | # i18n: column positioning for "hg summary" | ||
|
r17894 | ui.status(_('largefiles: (no remote repo)\n')) | ||
|
r17835 | elif not toupload: | ||
|
r17892 | # i18n: column positioning for "hg summary" | ||
|
r17835 | ui.status(_('largefiles: (no files to upload)\n')) | ||
|
r15168 | else: | ||
|
r17892 | # i18n: column positioning for "hg summary" | ||
|
r15168 | ui.status(_('largefiles: %d to upload\n') % len(toupload)) | ||
|
r17658 | def scmutiladdremove(orig, repo, pats=[], opts={}, dry_run=None, | ||
similarity=None): | ||||
|
r16636 | if not lfutil.islfilesrepo(repo): | ||
|
r17658 | return orig(repo, pats, opts, dry_run, similarity) | ||
|
r15792 | # Get the list of missing largefiles so we can remove them | ||
|
r17658 | lfdirstate = lfutil.openlfdirstate(repo.ui, repo) | ||
|
r15792 | 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. | ||||
|
r15967 | if missing: | ||
|
r17229 | m = [repo.wjoin(f) for f in missing] | ||
|
r15967 | repo._isaddremove = True | ||
|
r17658 | removelargefiles(repo.ui, repo, *m, **opts) | ||
|
r15967 | repo._isaddremove = False | ||
|
r15792 | # Call into the normal add code, and any files that *should* be added as | ||
# largefiles will be | ||||
|
r17658 | addlargefiles(repo.ui, repo, *pats, **opts) | ||
|
r15792 | # 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()) | ||||
|
r17658 | result = orig(repo, pats, opts, dry_run, similarity) | ||
|
r15792 | 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. | ||
|
r16247 | def overridepurge(orig, ui, repo, *dirs, **opts): | ||
|
r18012 | # XXX large file status is buggy when used on repo proxy. | ||
# XXX this needs to be investigate. | ||||
repo = repo.unfiltered() | ||||
|
r15168 | oldstatus = repo.status | ||
|
r16247 | def overridestatus(node1='.', node2=None, match=None, ignored=False, | ||
|
r15168 | 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 | ||||
|
r16247 | repo.status = overridestatus | ||
|
r15168 | orig(ui, repo, *dirs, **opts) | ||
repo.status = oldstatus | ||||
|
r16247 | def overriderollback(orig, ui, repo, **opts): | ||
|
r15168 | 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 | |||
|
r16247 | def overridetransplant(orig, ui, repo, *revs, **opts): | ||
|
r15982 | try: | ||
|
r16246 | oldstandins = lfutil.getstandinsstate(repo) | ||
|
r15982 | repo._istransplanting = True | ||
result = orig(ui, repo, *revs, **opts) | ||||
|
r16246 | newstandins = lfutil.getstandinsstate(repo) | ||
filelist = lfutil.getlfilestoupdate(oldstandins, newstandins) | ||||
lfcommands.updatelfiles(repo.ui, repo, filelist=filelist, | ||||
printmessage=True) | ||||
|
r15982 | finally: | ||
repo._istransplanting = False | ||||
|
r15383 | return result | ||
|
r16439 | |||
def overridecat(orig, ui, repo, file1, *pats, **opts): | ||||
|
r17269 | ctx = scmutil.revsingle(repo, opts.get('rev')) | ||
|
r18491 | err = 1 | ||
notbad = set() | ||||
m = scmutil.match(ctx, (file1,) + pats, opts) | ||||
origmatchfn = m.matchfn | ||||
def lfmatchfn(f): | ||||
lf = lfutil.splitstandin(f) | ||||
if lf is None: | ||||
return origmatchfn(f) | ||||
notbad.add(lf) | ||||
return origmatchfn(lf) | ||||
m.matchfn = lfmatchfn | ||||
|
r18974 | origbadfn = m.bad | ||
def lfbadfn(f, msg): | ||||
if not f in notbad: | ||||
return origbadfn(f, msg) | ||||
m.bad = lfbadfn | ||||
|
r18491 | for f in ctx.walk(m): | ||
|
r18974 | fp = cmdutil.makefileobj(repo, opts.get('output'), ctx.node(), | ||
pathname=f) | ||||
|
r18491 | lf = lfutil.splitstandin(f) | ||
if lf is None: | ||||
|
r18974 | # duplicating unreachable code from commands.cat | ||
data = ctx[f].data() | ||||
if opts.get('decode'): | ||||
data = repo.wwritedata(f, data) | ||||
fp.write(data) | ||||
|
r18491 | else: | ||
|
r18974 | hash = lfutil.readstandin(repo, lf, ctx.rev()) | ||
if not lfutil.inusercache(repo.ui, hash): | ||||
store = basestore._openstore(repo) | ||||
success, missing = store.get([(lf, hash)]) | ||||
if len(success) != 1: | ||||
raise util.Abort( | ||||
_('largefile %s is not in cache and could not be ' | ||||
'downloaded') % lf) | ||||
path = lfutil.usercachepath(repo.ui, hash) | ||||
fpin = open(path, "rb") | ||||
|
r19001 | for chunk in util.filechunkiter(fpin, 128 * 1024): | ||
|
r18974 | fp.write(chunk) | ||
fpin.close() | ||||
fp.close() | ||||
err = 0 | ||||
|
r18491 | return err | ||
|
r17878 | |||
def mercurialsinkbefore(orig, sink): | ||||
sink.repo._isconverting = True | ||||
orig(sink) | ||||
def mercurialsinkafter(orig, sink): | ||||
sink.repo._isconverting = False | ||||
orig(sink) | ||||