overrides.py
1287 lines
| 47.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 | ||||
|
r23183 | from mercurial import hg, util, cmdutil, scmutil, match as match_, \ | ||
|
r22285 | archival, pathutil, revset | ||
|
r15168 | from mercurial.i18n import _ | ||
from mercurial.node import hex | ||||
import lfutil | ||||
import lfcommands | ||||
|
r18974 | import basestore | ||
|
r15168 | |||
|
r15792 | # -- Utility functions: commonly/repeatedly needed functionality --------------- | ||
|
r15168 | def installnormalfilesmatchfn(manifest): | ||
|
r21090 | '''installmatchfn with a matchfn that ignores all largefiles''' | ||
|
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 | ||
|
r23145 | m.matchfn = lambda f: notlfile(f) and origmatchfn(f) | ||
|
r15168 | return m | ||
|
r16247 | oldmatch = installmatchfn(overridematch) | ||
|
r15168 | |||
def installmatchfn(f): | ||||
|
r21090 | '''monkey patch the scmutil module with a custom match function. | ||
Warning: it is monkey patching the _module_ on runtime! Not thread safe!''' | ||||
|
r15224 | oldmatch = scmutil.match | ||
|
r15168 | setattr(f, 'oldmatch', oldmatch) | ||
|
r15224 | scmutil.match = f | ||
|
r15168 | return oldmatch | ||
def restorematchfn(): | ||||
|
r21090 | '''restores scmutil.match to what it was before installmatchfn | ||
|
r15168 | was called. no-op if scmutil.match is its original function. | ||
|
r21090 | Note that n calls to installmatchfn will require n calls to | ||
|
r15168 | restore matchfn to reverse''' | ||
|
r21092 | scmutil.match = getattr(scmutil.match, 'oldmatch') | ||
|
r15168 | |||
|
r21110 | def installmatchandpatsfn(f): | ||
oldmatchandpats = scmutil.matchandpats | ||||
setattr(f, 'oldmatchandpats', oldmatchandpats) | ||||
scmutil.matchandpats = f | ||||
return oldmatchandpats | ||||
def restorematchandpatsfn(): | ||||
'''restores scmutil.matchandpats to what it was before | ||||
|
r23139 | installmatchandpatsfn was called. No-op if scmutil.matchandpats | ||
|
r21110 | is its original function. | ||
|
r23139 | Note that n calls to installmatchandpatsfn will require n calls | ||
|
r21110 | to restore matchfn to reverse''' | ||
scmutil.matchandpats = getattr(scmutil.matchandpats, 'oldmatchandpats', | ||||
scmutil.matchandpats) | ||||
|
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 = [] | ||||
|
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'): | ||||
|
r23041 | standins = [] | ||
|
r15168 | 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 | |||
|
r23038 | def removelargefiles(ui, repo, isaddremove, *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] | ||||
|
r22919 | for list in (s.modified, s.added, | ||
s.deleted, s.clean)] | ||||
|
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: | ||
|
r22630 | remove = deleted | ||
|
r18066 | result = warn(modified + added + clean, | ||
_('not removing %s: file still exists\n')) | ||||
|
r15168 | else: | ||
|
r22630 | remove = 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 | |||
|
r22630 | for f in sorted(remove): | ||
|
r15168 | 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. | ||||
|
r23038 | if isaddremove: | ||
|
r16231 | ui.status(_('removing %s\n') % f) | ||
|
r18386 | util.unlinkpath(repo.wjoin(f), ignoremissing=True) | ||
|
r15168 | lfdirstate.remove(f) | ||
lfdirstate.write() | ||||
remove = [lfutil.standin(f) for f in remove] | ||||
|
r15792 | # If this is being called by addremove, let the original addremove | ||
# function handle this. | ||||
|
r23038 | if not isaddremove: | ||
|
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() | ||
|
r23038 | return removelargefiles(ui, repo, False, *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): | ||
|
r21110 | def overridematchandpats(ctx, pats=[], opts={}, globbed=False, | ||
|
r18341 | 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. | ||||
""" | ||||
|
r21110 | matchandpats = oldmatchandpats(ctx, pats, opts, globbed, default) | ||
m, p = copy.copy(matchandpats) | ||||
|
r22170 | if m.always(): | ||
# We want to match everything anyway, so there's no benefit trying | ||||
# to add standins. | ||||
return matchandpats | ||||
|
r21110 | pats = set(p) | ||
# TODO: handling of patterns in both cases below | ||||
if m._cwd: | ||||
|
r21209 | if os.path.isabs(m._cwd): | ||
# TODO: handle largefile magic when invoked from other cwd | ||||
return matchandpats | ||||
|
r21110 | back = (m._cwd.count('/') + 1) * '../' | ||
pats.update(back + lfutil.standin(m._cwd + '/' + f) for f in p) | ||||
else: | ||||
pats.update(lfutil.standin(f) for f in p) | ||||
|
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 | ||||
|
r21275 | elif m._files[i] not in repo[ctx.node()]: | ||
m._files.append(standin) | ||||
|
r21110 | pats.add(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 | ||||
|
r21110 | |||
return m, pats | ||||
|
r22169 | # For hg log --patch, the match object is used in two different senses: | ||
# (1) to determine what revisions should be printed out, and | ||||
# (2) to determine what files to print out diffs for. | ||||
# The magic matchandpats override should be used for case (1) but not for | ||||
# case (2). | ||||
def overridemakelogfilematcher(repo, pats, opts): | ||||
pctx = repo[None] | ||||
match, pats = oldmatchandpats(pctx, pats, opts) | ||||
return lambda rev: match | ||||
|
r21110 | oldmatchandpats = installmatchandpatsfn(overridematchandpats) | ||
|
r22169 | oldmakelogfilematcher = cmdutil._makenofollowlogfilematcher | ||
setattr(cmdutil, '_makenofollowlogfilematcher', overridemakelogfilematcher) | ||||
|
r15168 | try: | ||
|
r17577 | return orig(ui, repo, *pats, **opts) | ||
|
r15168 | finally: | ||
|
r21110 | restorematchandpatsfn() | ||
|
r22169 | setattr(cmdutil, '_makenofollowlogfilematcher', oldmakelogfilematcher) | ||
|
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: | ||||
|
r21088 | class fakerepo(object): | ||
dirstate = lfutil.openlfdirstate(ui, repo) | ||||
orig(ui, fakerepo, *pats, **opts) | ||||
|
r18144 | 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): | ||
|
r15252 | # Need to lock between the standins getting updated and their | ||
# largefiles getting updated | ||||
|
r15168 | wlock = repo.wlock() | ||
try: | ||||
|
r23040 | if opts['check']: | ||
lfdirstate = lfutil.openlfdirstate(ui, repo) | ||||
unsure, s = lfdirstate.status( | ||||
match_.always(repo.root, repo.getcwd()), | ||||
[], False, False, False) | ||||
|
r21089 | |||
|
r22919 | mod = len(s.modified) > 0 | ||
|
r15168 | 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')) | ||
|
r21089 | return orig(ui, repo, *pats, **opts) | ||
|
r15168 | finally: | ||
wlock.release() | ||||
|
r15663 | # Before starting the manifest merge, merge.updates will call | ||
|
r23319 | # checkunknown to check if there are any files in the merged-in | ||
|
r15663 | # 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 | ||||
|
r23307 | # case further in the overridden calculateupdates 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. | ||||
# | ||||
|
r23307 | # The strategy is to run the original calculateupdates and then process | ||
|
r15663 | # 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. | ||||
|
r21081 | def overridecalculateupdates(origfn, repo, p1, p2, pas, branchmerge, force, | ||
|
r21080 | partial, acceptremote, followcopies): | ||
|
r18605 | overwrite = force and not branchmerge | ||
|
r21081 | actions = origfn(repo, p1, p2, pas, branchmerge, force, partial, | ||
|
r21080 | acceptremote, followcopies) | ||
|
r19952 | |||
if overwrite: | ||||
return actions | ||||
|
r21545 | removes = set(a[0] for a in actions['r']) | ||
|
r15663 | |||
|
r21545 | newglist = [] | ||
|
r22196 | lfmr = [] # LargeFiles: Mark as Removed | ||
|
r21545 | for action in actions['g']: | ||
f, args, msg = action | ||||
|
r20148 | splitstandin = f and lfutil.splitstandin(f) | ||
|
r21545 | if (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: | ||||
|
r21545 | actions['r'].append((lfile, None, msg)) | ||
newglist.append((standin, (p2.flags(standin),), msg)) | ||||
|
r15663 | else: | ||
|
r21545 | actions['r'].append((standin, None, msg)) | ||
elif 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: | ||||
|
r22196 | if branchmerge: | ||
# largefile can be restored from standin safely | ||||
actions['r'].append((lfile, None, msg)) | ||||
else: | ||||
# "lfile" should be marked as "removed" without | ||||
# removal of itself | ||||
lfmr.append((lfile, None, msg)) | ||||
# linear-merge should treat this largefile as 're-added' | ||||
actions['a'].append((standin, None, msg)) | ||||
|
r15663 | else: | ||
|
r21545 | actions['r'].append((standin, None, msg)) | ||
newglist.append((lfile, (p2.flags(lfile),), msg)) | ||||
|
r15663 | else: | ||
|
r21545 | newglist.append(action) | ||
|
r15663 | |||
|
r21545 | newglist.sort() | ||
actions['g'] = newglist | ||||
|
r22196 | if lfmr: | ||
lfmr.sort() | ||||
actions['lfmr'] = lfmr | ||||
|
r21545 | |||
return actions | ||||
|
r15663 | |||
|
r22196 | def mergerecordupdates(orig, repo, actions, branchmerge): | ||
if 'lfmr' in actions: | ||||
# this should be executed before 'orig', to execute 'remove' | ||||
# before all other actions | ||||
for lfile, args, msg in actions['lfmr']: | ||||
repo.dirstate.remove(lfile) | ||||
return orig(repo, actions, branchmerge) | ||||
|
r15252 | # Override filemerge to prompt the user about how they wish to merge | ||
|
r20295 | # largefiles. This will handle identical edits without prompting the user. | ||
|
r21524 | def overridefilemerge(origfn, repo, mynode, orig, fcd, fco, fca, labels=None): | ||
|
r15168 | if not lfutil.isstandin(orig): | ||
|
r21524 | return origfn(repo, mynode, orig, fcd, fco, fca, labels=labels) | ||
|
r20298 | |||
|
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 | ||||
|
r21091 | installnormalfilesmatchfn(repo[None].manifest()) | ||
|
r15168 | try: | ||
|
r15279 | try: | ||
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() | ||
|
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) | ||||
|
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)) | ||
|
r21196 | |||
# The file is gone, but this deletes any empty parent | ||||
# directories as a side-effect. | ||||
util.unlinkpath(repo.wjoin(srclfile), True) | ||||
|
r15598 | 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 | ||||
|
r21094 | # resulting standins update the largefiles. | ||
|
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) | ||||
|
r23039 | s = lfutil.lfdirstatestatus(lfdirstate, repo) | ||
|
r18140 | lfdirstate.write() | ||
|
r22919 | for lfile in s.modified: | ||
|
r15168 | lfutil.updatestandin(repo, lfutil.standin(lfile)) | ||
|
r22919 | for lfile in s.deleted: | ||
|
r16638 | if (os.path.exists(repo.wjoin(lfutil.standin(lfile)))): | ||
os.unlink(repo.wjoin(lfutil.standin(lfile))) | ||||
|
r15168 | |||
|
r21094 | oldstandins = lfutil.getstandinsstate(repo) | ||
|
r21095 | def overridematch(ctx, pats=[], opts={}, globbed=False, | ||
default='relpath'): | ||||
match = oldmatch(ctx, pats, opts, globbed, default) | ||||
m = copy.copy(match) | ||||
def tostandin(f): | ||||
if 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) | ||||
origmatchfn = m.matchfn | ||||
def matchfn(f): | ||||
if lfutil.isstandin(f): | ||||
return (origmatchfn(lfutil.splitstandin(f)) and | ||||
(f in repo[None] or f in ctx)) | ||||
return origmatchfn(f) | ||||
m.matchfn = matchfn | ||||
return m | ||||
oldmatch = installmatchfn(overridematch) | ||||
|
r15168 | try: | ||
orig(ui, repo, *pats, **opts) | ||||
finally: | ||||
restorematchfn() | ||||
|
r15254 | |||
|
r21094 | newstandins = lfutil.getstandinsstate(repo) | ||
filelist = lfutil.getlfilestoupdate(oldstandins, newstandins) | ||||
|
r21934 | # lfdirstate should be 'normallookup'-ed for updated files, | ||
# because reverting doesn't touch dirstate for 'normal' files | ||||
# when target revision is explicitly specified: in such case, | ||||
# 'n' and valid timestamp in dirstate doesn't ensure 'clean' | ||||
# of target (standin) file. | ||||
lfcommands.updatelfiles(ui, repo, filelist, printmessage=False, | ||||
normallookup=True) | ||||
|
r21094 | |||
|
r15168 | finally: | ||
wlock.release() | ||||
|
r23183 | # after pulling changesets, we need to take some extra care to get | ||
# largefiles updated remotely | ||||
|
r16247 | def overridepull(orig, ui, repo, source=None, **opts): | ||
|
r16692 | revsprepull = len(repo) | ||
|
r18977 | if not source: | ||
source = 'default' | ||||
repo.lfpullsource = source | ||||
|
r23183 | 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(_( | ||
|
r21096 | '--all-largefiles is incompatible with non-local destination %s') % | ||
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): | ||
|
r23187 | resuming = opts.get('continue') | ||
repo._lfcommithooks.append(lfutil.automatedcommithook(resuming)) | ||||
|
r23190 | repo._lfstatuswriters.append(lambda *msg, **opts: None) | ||
|
r15168 | try: | ||
|
r17578 | return orig(ui, repo, **opts) | ||
|
r15168 | finally: | ||
|
r23190 | repo._lfstatuswriters.pop() | ||
|
r23187 | repo._lfcommithooks.pop() | ||
|
r15168 | |||
|
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 | ||||
|
r22919 | s = repo.status() | ||
|
r15168 | repo.lfstatus = False | ||
|
r22919 | if s.modified or s.added or s.removed or s.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 | ||
|
r22919 | s = repo.status() | ||
|
r15168 | repo.lfstatus = False | ||
|
r22919 | if s.modified or s.added or s.removed or s.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 | ||||
|
r22919 | forget = sorted(s.modified + s.added + s.deleted + s.clean) | ||
|
r15168 | 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 | ||
|
r21884 | def _getoutgoings(repo, other, missing, addfunc): | ||
|
r21882 | """get pairs of filename and largefile hash in outgoing revisions | ||
in 'missing'. | ||||
|
r21884 | largefiles already existing on 'other' repository are ignored. | ||
|
r21882 | 'addfunc' is invoked with each unique pairs of filename and | ||
largefile hash value. | ||||
""" | ||||
knowns = set() | ||||
|
r21884 | lfhashes = set() | ||
|
r21882 | def dedup(fn, lfhash): | ||
k = (fn, lfhash) | ||||
if k not in knowns: | ||||
knowns.add(k) | ||||
|
r21884 | lfhashes.add(lfhash) | ||
|
r21882 | lfutil.getlfilestoupload(repo, missing, dedup) | ||
|
r21884 | if lfhashes: | ||
lfexists = basestore._openstore(repo, other).exists(lfhashes) | ||||
for fn, lfhash in knowns: | ||||
if not lfexists[lfhash]: # lfhash doesn't exist on "other" | ||||
addfunc(fn, lfhash) | ||||
|
r21882 | |||
|
r21052 | def outgoinghook(ui, repo, other, opts, missing): | ||
|
r15168 | if opts.pop('large', None): | ||
|
r21883 | lfhashes = set() | ||
if ui.debugflag: | ||||
toupload = {} | ||||
def addfunc(fn, lfhash): | ||||
if fn not in toupload: | ||||
toupload[fn] = [] | ||||
toupload[fn].append(lfhash) | ||||
lfhashes.add(lfhash) | ||||
def showhashes(fn): | ||||
for lfhash in sorted(toupload[fn]): | ||||
ui.debug(' %s\n' % (lfhash)) | ||||
else: | ||||
toupload = set() | ||||
def addfunc(fn, lfhash): | ||||
toupload.add(fn) | ||||
lfhashes.add(lfhash) | ||||
def showhashes(fn): | ||||
pass | ||||
|
r21884 | _getoutgoings(repo, other, missing, addfunc) | ||
|
r21883 | |||
|
r21052 | if not toupload: | ||
|
r17835 | ui.status(_('largefiles: no files to upload\n')) | ||
|
r15168 | else: | ||
|
r21883 | ui.status(_('largefiles to upload (%d entities):\n') | ||
% (len(lfhashes))) | ||||
|
r21052 | for file in sorted(toupload): | ||
|
r15168 | ui.status(lfutil.splitstandin(file) + '\n') | ||
|
r21883 | showhashes(file) | ||
|
r15168 | ui.status('\n') | ||
|
r21048 | def summaryremotehook(ui, repo, opts, changes): | ||
largeopt = opts.get('large', False) | ||||
if changes is None: | ||||
if largeopt: | ||||
return (False, True) # only outgoing check is needed | ||||
else: | ||||
return (False, False) | ||||
elif largeopt: | ||||
url, branch, peer, outgoing = changes[1] | ||||
if peer is None: | ||||
# i18n: column positioning for "hg summary" | ||||
ui.status(_('largefiles: (no remote repo)\n')) | ||||
return | ||||
toupload = set() | ||||
|
r21882 | lfhashes = set() | ||
def addfunc(fn, lfhash): | ||||
toupload.add(fn) | ||||
lfhashes.add(lfhash) | ||||
|
r21884 | _getoutgoings(repo, peer, outgoing.missing, addfunc) | ||
|
r21882 | |||
|
r21048 | if not toupload: | ||
# i18n: column positioning for "hg summary" | ||||
ui.status(_('largefiles: (no files to upload)\n')) | ||||
else: | ||||
# i18n: column positioning for "hg summary" | ||||
|
r21882 | ui.status(_('largefiles: %d entities for %d files to upload\n') | ||
% (len(lfhashes), len(toupload))) | ||||
|
r21048 | |||
|
r16247 | def overridesummary(orig, ui, repo, *pats, **opts): | ||
|
r15787 | try: | ||
repo.lfstatus = True | ||||
orig(ui, repo, *pats, **opts) | ||||
finally: | ||||
repo.lfstatus = False | ||||
|
r15168 | |||
|
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) | ||
|
r22911 | unsure, s = lfdirstate.status(match_.always(repo.root, repo.getcwd()), [], | ||
False, False, False) | ||||
|
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. | ||||
|
r22919 | if s.deleted: | ||
m = [repo.wjoin(f) for f in s.deleted] | ||||
|
r23038 | removelargefiles(repo.ui, repo, True, *m, **opts) | ||
|
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) | ||||
|
r22919 | unknown = [f for f in r.unknown if lfdirstate[f] == '?'] | ||
ignored = [f for f in r.ignored if lfdirstate[f] == '?'] | ||||
return scmutil.status(r.modified, r.added, r.removed, r.deleted, | ||||
unknown, ignored, r.clean) | ||||
|
r16247 | repo.status = overridestatus | ||
|
r15168 | orig(ui, repo, *dirs, **opts) | ||
repo.status = oldstatus | ||||
|
r16247 | def overriderollback(orig, ui, repo, **opts): | ||
|
r15794 | wlock = repo.wlock() | ||
try: | ||||
|
r22283 | before = repo.dirstate.parents() | ||
|
r22286 | orphans = set(f for f in repo.dirstate | ||
if lfutil.isstandin(f) and repo.dirstate[f] != 'r') | ||||
|
r22094 | result = orig(ui, repo, **opts) | ||
|
r22283 | after = repo.dirstate.parents() | ||
if before == after: | ||||
return result # no need to restore standins | ||||
|
r22285 | pctx = repo['.'] | ||
for f in repo.dirstate: | ||||
if lfutil.isstandin(f): | ||||
|
r22286 | orphans.discard(f) | ||
|
r22285 | if repo.dirstate[f] == 'r': | ||
repo.wvfs.unlinkpath(f, ignoremissing=True) | ||||
elif f in pctx: | ||||
fctx = pctx[f] | ||||
repo.wwrite(f, fctx.data(), fctx.flags()) | ||||
else: | ||||
# content of standin is not so important in 'a', | ||||
# 'm' or 'n' (coming from the 2nd parent) cases | ||||
lfutil.writestandin(repo, f, '', False) | ||||
|
r22286 | for standin in orphans: | ||
repo.wvfs.unlinkpath(standin, ignoremissing=True) | ||||
|
r22094 | |||
|
r15794 | lfdirstate = lfutil.openlfdirstate(ui, repo) | ||
|
r22097 | orphans = set(lfdirstate) | ||
|
r15794 | lfiles = lfutil.listlfiles(repo) | ||
for file in lfiles: | ||||
|
r22096 | lfutil.synclfdirstate(repo, lfdirstate, file, True) | ||
|
r22097 | orphans.discard(file) | ||
for lfile in orphans: | ||||
lfdirstate.drop(lfile) | ||||
|
r15794 | lfdirstate.write() | ||
finally: | ||||
wlock.release() | ||||
|
r15168 | return result | ||
|
r15383 | |||
|
r16247 | def overridetransplant(orig, ui, repo, *revs, **opts): | ||
|
r23274 | resuming = opts.get('continue') | ||
repo._lfcommithooks.append(lfutil.automatedcommithook(resuming)) | ||||
|
r23275 | repo._lfstatuswriters.append(lambda *msg, **opts: None) | ||
|
r15982 | try: | ||
result = orig(ui, repo, *revs, **opts) | ||||
finally: | ||||
|
r23275 | repo._lfstatuswriters.pop() | ||
|
r23274 | repo._lfcommithooks.pop() | ||
|
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): | ||||
|
r21087 | if origmatchfn(f): | ||
return True | ||||
|
r18491 | lf = lfutil.splitstandin(f) | ||
if lf is None: | ||||
|
r21087 | return False | ||
|
r18491 | notbad.add(lf) | ||
return origmatchfn(lf) | ||||
m.matchfn = lfmatchfn | ||||
|
r18974 | origbadfn = m.bad | ||
def lfbadfn(f, msg): | ||||
if not f in notbad: | ||||
|
r21086 | origbadfn(f, msg) | ||
|
r18974 | 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) | ||
|
r21087 | if lf is None or origmatchfn(f): | ||
|
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 | |||
|
r22288 | def mergeupdate(orig, repo, node, branchmerge, force, partial, | ||
*args, **kwargs): | ||||
wlock = repo.wlock() | ||||
try: | ||||
# branch | | | | ||||
# merge | force | partial | action | ||||
# -------+-------+---------+-------------- | ||||
# x | x | x | linear-merge | ||||
# o | x | x | branch-merge | ||||
# x | o | x | overwrite (as clean update) | ||||
# o | o | x | force-branch-merge (*1) | ||||
# x | x | o | (*) | ||||
# o | x | o | (*) | ||||
# x | o | o | overwrite (as revert) | ||||
# o | o | o | (*) | ||||
# | ||||
# (*) don't care | ||||
# (*1) deprecated, but used internally (e.g: "rebase --collapse") | ||||
linearmerge = not branchmerge and not force and not partial | ||||
if linearmerge or (branchmerge and force and not partial): | ||||
# update standins for linear-merge or force-branch-merge, | ||||
# because largefiles in the working directory may be modified | ||||
lfdirstate = lfutil.openlfdirstate(repo.ui, repo) | ||||
|
r22911 | unsure, s = lfdirstate.status(match_.always(repo.root, | ||
repo.getcwd()), | ||||
[], False, False, False) | ||||
|
r22919 | for lfile in unsure + s.modified + s.added: | ||
|
r22288 | lfutil.updatestandin(repo, lfutil.standin(lfile)) | ||
if linearmerge: | ||||
# Only call updatelfiles on the standins that have changed | ||||
# to save time | ||||
oldstandins = lfutil.getstandinsstate(repo) | ||||
result = orig(repo, node, branchmerge, force, partial, *args, **kwargs) | ||||
filelist = None | ||||
if linearmerge: | ||||
newstandins = lfutil.getstandinsstate(repo) | ||||
filelist = lfutil.getlfilestoupdate(oldstandins, newstandins) | ||||
lfcommands.updatelfiles(repo.ui, repo, filelist=filelist, | ||||
normallookup=partial) | ||||
return result | ||||
finally: | ||||
wlock.release() | ||||
|
r22289 | |||
def scmutilmarktouched(orig, repo, files, *args, **kwargs): | ||||
result = orig(repo, files, *args, **kwargs) | ||||
filelist = [lfutil.splitstandin(f) for f in files if lfutil.isstandin(f)] | ||||
if filelist: | ||||
lfcommands.updatelfiles(repo.ui, repo, filelist=filelist, | ||||
printmessage=False, normallookup=True) | ||||
return result | ||||