def override_rollback(orig, ui, repo, **opts):
result = orig(ui, repo, **opts)
merge.update(repo, node=None, branchmerge=False, force=True,
partial=lfutil.isstandin)
lfdirstate = lfutil.openlfdirstate(ui, repo)
lfiles = lfutil.listlfiles(repo)
oldlfiles = lfutil.listlfiles(repo, repo[None].parents()[0].rev())
for file in lfiles:
if file in oldlfiles:
lfdirstate.normallookup(file)
else:
lfdirstate.add(file)
lfdirstate.write()
return result
def cachelfiles(ui, repo, node):
'''cachelfiles ensures that all largefiles needed by the specified revision
are present in the repository's largefile cache.
returns a tuple (cached, missing). cached is the list of files downloaded
by this operation; missing is the list of files that were needed but could
not be found.'''
lfiles = lfutil.listlfiles(repo, node)
toget = []
for lfile in lfiles:
# If we are mid-merge, then we have to trust the standin that is in the
# working copy to have the correct hashvalue. This is because the
# original hg.merge() already updated the standin as part of the normal
# merge process -- we just have to udpate the largefile to match.
if (getattr(repo, "_ismerging", False) and
os.path.exists(repo.wjoin(lfutil.standin(lfile)))):
expectedhash = lfutil.readstandin(repo, lfile)
else:
expectedhash = repo[node][lfutil.standin(lfile)].data().strip()
# if it exists and its hash matches, it might have been locally
# modified before updating and the user chose 'local'. in this case,
# it will not be in any store, so don't look for it.
if ((not os.path.exists(repo.wjoin(lfile)) or
expectedhash != lfutil.hashfile(repo.wjoin(lfile))) and
not lfutil.findfile(repo, expectedhash)):
toget.append((lfile, expectedhash))
if toget:
store = basestore._openstore(repo)
ret = store.get(toget)
return ret
return ([], [])
def updatelfiles(ui, repo, filelist=None, printmessage=True):
wlock = repo.wlock()
try:
lfdirstate = lfutil.openlfdirstate(ui, repo)
lfiles = set(lfutil.listlfiles(repo)) | set(lfdirstate)
if filelist is not None:
lfiles = [f for f in lfiles if f in filelist]
printed = False
if printmessage and lfiles:
ui.status(_('getting changed largefiles\n'))
printed = True
cachelfiles(ui, repo, '.')
updated, removed = 0, 0
for i in map(lambda f: _updatelfile(repo, lfdirstate, f), lfiles):
# increment the appropriate counter according to _updatelfile's
# return value
updated += i > 0 and i or 0
removed -= i < 0 and i or 0
if printmessage and (removed or updated) and not printed:
ui.status(_('getting changed largefiles\n'))
printed = True
lfdirstate.write()
if printed and printmessage:
ui.status(_('%d largefiles updated, %d removed\n') % (updated,
removed))
finally:
wlock.release()
def updatelfiles(ui, repo, filelist=None, printmessage=True):
wlock = repo.wlock()
try:
lfdirstate = lfutil.openlfdirstate(ui, repo)
lfiles = set(lfutil.listlfiles(repo)) | set(lfdirstate)
if filelist is not None:
lfiles = [f for f in lfiles if f in filelist]
printed = False
if printmessage and lfiles:
ui.status(_('getting changed largefiles\n'))
printed = True
cachelfiles(ui, repo, None, lfiles)
updated, removed = 0, 0
for f in lfiles:
i = _updatelfile(repo, lfdirstate, f)
if i:
if i > 0:
updated += i
else:
removed -= i
if printmessage and (removed or updated) and not printed:
ui.status(_('getting changed largefiles\n'))
printed = True
lfdirstate.write()
if printed and printmessage:
ui.status(_('%d largefiles updated, %d removed\n') % (updated,
removed))
finally:
wlock.release()
def cachelfiles(ui, repo, node):
'''cachelfiles ensures that all largefiles needed by the specified revision
are present in the repository's largefile cache.
returns a tuple (cached, missing). cached is the list of files downloaded
by this operation; missing is the list of files that were needed but could
not be found.'''
lfiles = lfutil.listlfiles(repo, node)
toget = []
for lfile in lfiles:
expectedhash = repo[node][lfutil.standin(lfile)].data().strip()
# if it exists and its hash matches, it might have been locally
# modified before updating and the user chose 'local'. in this case,
# it will not be in any store, so don't look for it.
if ((not os.path.exists(repo.wjoin(lfile)) or
expectedhash != lfutil.hashfile(repo.wjoin(lfile))) and
not lfutil.findfile(repo, expectedhash)):
toget.append((lfile, expectedhash))
if toget:
store = basestore._openstore(repo)
ret = store.get(toget)
return ret
return ([], [])
def cachelfiles(ui, repo, node, filelist=None):
'''cachelfiles ensures that all largefiles needed by the specified revision
are present in the repository's largefile cache.
returns a tuple (cached, missing). cached is the list of files downloaded
by this operation; missing is the list of files that were needed but could
not be found.'''
lfiles = lfutil.listlfiles(repo, node)
if filelist:
lfiles = set(lfiles) & set(filelist)
toget = []
for lfile in lfiles:
try:
expectedhash = repo[node][lfutil.standin(lfile)].data().strip()
except IOError as err:
if err.errno == errno.ENOENT:
continue # node must be None and standin wasn't found in wctx
raise
if not lfutil.findfile(repo, expectedhash):
toget.append((lfile, expectedhash))
if toget:
store = basestore._openstore(repo)
ret = store.get(toget)
return ret
return ([], [])
def updatelfiles(ui, repo, filelist=None, printmessage=True):
wlock = repo.wlock()
try:
lfdirstate = lfutil.openlfdirstate(ui, repo)
lfiles = set(lfutil.listlfiles(repo)) | set(lfdirstate)
if filelist is not None:
lfiles = [f for f in lfiles if f in filelist]
printed = False
if printmessage and lfiles:
ui.status(_("getting changed largefiles\n"))
printed = True
cachelfiles(ui, repo, ".")
updated, removed = 0, 0
for i in map(lambda f: _updatelfile(repo, lfdirstate, f), lfiles):
# increment the appropriate counter according to _updatelfile's
# return value
updated += i > 0 and i or 0
removed -= i < 0 and i or 0
if printmessage and (removed or updated) and not printed:
ui.status(_("getting changed largefiles\n"))
printed = True
lfdirstate.write()
if printed and printmessage:
ui.status(_("%d largefiles updated, %d removed\n") % (updated, removed))
finally:
wlock.release()
def cachelfiles(ui, repo, node, filelist=None):
'''cachelfiles ensures that all largefiles needed by the specified revision
are present in the repository's largefile cache.
returns a tuple (cached, missing). cached is the list of files downloaded
by this operation; missing is the list of files that were needed but could
not be found.'''
lfiles = lfutil.listlfiles(repo, node)
if filelist:
lfiles = set(lfiles) & set(filelist)
toget = []
for lfile in lfiles:
try:
expectedhash = repo[node][lfutil.standin(lfile)].data().strip()
except IOError as err:
if err.errno == errno.ENOENT:
continue # node must be None and standin wasn't found in wctx
raise
if not lfutil.findfile(repo, expectedhash):
toget.append((lfile, expectedhash))
if toget:
store = basestore._openstore(repo)
ret = store.get(toget)
return ret
return ([], [])
def updatelfiles(ui, repo, filelist=None, printmessage=True):
wlock = repo.wlock()
try:
lfdirstate = lfutil.openlfdirstate(ui, repo)
lfiles = set(lfutil.listlfiles(repo)) | set(lfdirstate)
if filelist is not None:
lfiles = [f for f in lfiles if f in filelist]
printed = False
if printmessage and lfiles:
ui.status(_('getting changed largefiles\n'))
printed = True
cachelfiles(ui, repo, None, lfiles)
updated, removed = 0, 0
for f in lfiles:
i = _updatelfile(repo, lfdirstate, f)
if i:
if i > 0:
updated += i
else:
removed -= i
if printmessage and (removed or updated) and not printed:
ui.status(_('getting changed largefiles\n'))
printed = True
lfdirstate.write()
if printed and printmessage:
ui.status(
_('%d largefiles updated, %d removed\n') % (updated, removed))
finally:
wlock.release()
def cachelfiles(ui, repo, node):
"""cachelfiles ensures that all largefiles needed by the specified revision
are present in the repository's largefile cache.
returns a tuple (cached, missing). cached is the list of files downloaded
by this operation; missing is the list of files that were needed but could
not be found."""
lfiles = lfutil.listlfiles(repo, node)
toget = []
for lfile in lfiles:
# If we are mid-merge, then we have to trust the standin that is in the
# working copy to have the correct hashvalue. This is because the
# original hg.merge() already updated the standin as part of the normal
# merge process -- we just have to udpate the largefile to match.
if getattr(repo, "_ismerging", False) and os.path.exists(repo.wjoin(lfutil.standin(lfile))):
expectedhash = lfutil.readstandin(repo, lfile)
else:
expectedhash = repo[node][lfutil.standin(lfile)].data().strip()
# if it exists and its hash matches, it might have been locally
# modified before updating and the user chose 'local'. in this case,
# it will not be in any store, so don't look for it.
if (
not os.path.exists(repo.wjoin(lfile)) or expectedhash != lfutil.hashfile(repo.wjoin(lfile))
) and not lfutil.findfile(repo, expectedhash):
toget.append((lfile, expectedhash))
if toget:
store = basestore._openstore(repo)
ret = store.get(toget)
return ret
return ([], [])
def override_rollback(orig, ui, repo, **opts):
result = orig(ui, repo, **opts)
merge.update(repo,
node=None,
branchmerge=False,
force=True,
partial=lfutil.isstandin)
lfdirstate = lfutil.openlfdirstate(ui, repo)
lfiles = lfutil.listlfiles(repo)
oldlfiles = lfutil.listlfiles(repo, repo[None].parents()[0].rev())
for file in lfiles:
if file in oldlfiles:
lfdirstate.normallookup(file)
else:
lfdirstate.add(file)
lfdirstate.write()
return result
def updatelfiles(ui,
repo,
filelist=None,
printmessage=None,
normallookup=False,
checked=False):
'''Update largefiles according to standins in the working directory
If ``printmessage`` is other than ``None``, it means "print (or
ignore, for false) message forcibly".
'''
statuswriter = lfutil.getstatuswriter(ui, repo, printmessage)
wlock = repo.wlock()
try:
lfdirstate = lfutil.openlfdirstate(ui, repo)
lfiles = set(lfutil.listlfiles(repo)) | set(lfdirstate)
if filelist is not None:
filelist = set(filelist)
lfiles = [f for f in lfiles if f in filelist]
update = {}
updated, removed = 0, 0
for lfile in lfiles:
abslfile = repo.wjoin(lfile)
absstandin = repo.wjoin(lfutil.standin(lfile))
if os.path.exists(absstandin):
if (os.path.exists(absstandin + '.orig')
and os.path.exists(abslfile)):
shutil.copyfile(abslfile, abslfile + '.orig')
util.unlinkpath(absstandin + '.orig')
expecthash = lfutil.readstandin(repo, lfile)
if (expecthash != ''
and (checked or not os.path.exists(abslfile)
or expecthash != lfutil.hashfile(abslfile))):
if lfile not in repo[None]: # not switched to normal file
util.unlinkpath(abslfile, ignoremissing=True)
# use normallookup() to allocate an entry in largefiles
# dirstate, because lack of it misleads
# lfilesrepo.status() into recognition that such cache
# missing files are removed.
lfdirstate.normallookup(lfile)
update[lfile] = expecthash
else:
# Remove lfiles for which the standin is deleted, unless the
# lfile is added to the repository again. This happens when a
# largefile is converted back to a normal file: the standin
# disappears, but a new (normal) file appears as the lfile.
if (os.path.exists(abslfile)
and repo.dirstate.normalize(lfile) not in repo[None]):
util.unlinkpath(abslfile)
removed += 1
# largefile processing might be slow and be interrupted - be prepared
lfdirstate.write()
if lfiles:
statuswriter(_('getting changed largefiles\n'))
cachelfiles(ui, repo, None, lfiles)
for lfile in lfiles:
update1 = 0
expecthash = update.get(lfile)
if expecthash:
if not lfutil.copyfromcache(repo, expecthash, lfile):
# failed ... but already removed and set to normallookup
continue
# Synchronize largefile dirstate to the last modified
# time of the file
lfdirstate.normal(lfile)
update1 = 1
# copy the state of largefile standin from the repository's
# dirstate to its state in the lfdirstate.
abslfile = repo.wjoin(lfile)
absstandin = repo.wjoin(lfutil.standin(lfile))
if os.path.exists(absstandin):
mode = os.stat(absstandin).st_mode
if mode != os.stat(abslfile).st_mode:
os.chmod(abslfile, mode)
update1 = 1
updated += update1
lfutil.synclfdirstate(repo, lfdirstate, lfile, normallookup)
lfdirstate.write()
if lfiles:
statuswriter(
_('%d largefiles updated, %d removed\n') % (updated, removed))
finally:
wlock.release()
def commit(self, text="", user=None, date=None, match=None,
force=False, editor=False, extra={}):
orig = super(lfiles_repo, self).commit
wlock = repo.wlock()
try:
if getattr(repo, "_isrebasing", False):
# We have to take the time to pull down the new
# largefiles now. Otherwise if we are rebasing,
# any largefiles that were modified in the
# destination changesets get overwritten, either
# by the rebase or in the first commit after the
# rebase.
lfcommands.updatelfiles(repo.ui, repo)
# Case 1: user calls commit with no specific files or
# include/exclude patterns: refresh and commit all files that
# are "dirty".
if ((match is None) or
(not match.anypats() and not match.files())):
# Spend a bit of time here to get a list of files we know
# are modified so we can compare only against those.
# It can cost a lot of time (several seconds)
# otherwise to update all standins if the largefiles are
# large.
lfdirstate = lfutil.openlfdirstate(ui, self)
dirtymatch = match_.always(repo.root, repo.getcwd())
s = lfdirstate.status(dirtymatch, [], False, False, False)
modifiedfiles = []
for i in s:
modifiedfiles.extend(i)
lfiles = lfutil.listlfiles(self)
# this only loops through largefiles that exist (not
# removed/renamed)
for lfile in lfiles:
if lfile in modifiedfiles:
if os.path.exists(self.wjoin(lfutil.standin(lfile))):
# this handles the case where a rebase is being
# performed and the working copy is not updated
# yet.
if os.path.exists(self.wjoin(lfile)):
lfutil.updatestandin(self,
lfutil.standin(lfile))
lfdirstate.normal(lfile)
for lfile in lfdirstate:
if lfile in modifiedfiles:
if not os.path.exists(
repo.wjoin(lfutil.standin(lfile))):
lfdirstate.drop(lfile)
lfdirstate.write()
return orig(text=text, user=user, date=date, match=match,
force=force, editor=editor, extra=extra)
for f in match.files():
if lfutil.isstandin(f):
raise util.Abort(
_('file "%s" is a largefile standin') % f,
hint=('commit the largefile itself instead'))
# Case 2: user calls commit with specified patterns: refresh
# any matching big files.
smatcher = lfutil.composestandinmatcher(self, match)
standins = lfutil.dirstate_walk(self.dirstate, smatcher)
# No matching big files: get out of the way and pass control to
# the usual commit() method.
if not standins:
return orig(text=text, user=user, date=date, match=match,
force=force, editor=editor, extra=extra)
# Refresh all matching big files. It's possible that the
# commit will end up failing, in which case the big files will
# stay refreshed. No harm done: the user modified them and
# asked to commit them, so sooner or later we're going to
# refresh the standins. Might as well leave them refreshed.
lfdirstate = lfutil.openlfdirstate(ui, self)
for standin in standins:
lfile = lfutil.splitstandin(standin)
if lfdirstate[lfile] <> 'r':
lfutil.updatestandin(self, standin)
lfdirstate.normal(lfile)
else:
lfdirstate.drop(lfile)
lfdirstate.write()
# Cook up a new matcher that only matches regular files or
# standins corresponding to the big files requested by the
# user. Have to modify _files to prevent commit() from
# complaining "not tracked" for big files.
lfiles = lfutil.listlfiles(repo)
match = copy.copy(match)
orig_matchfn = match.matchfn
# Check both the list of largefiles and the list of
# standins because if a largefile was removed, it
# won't be in the list of largefiles at this point
match._files += sorted(standins)
actualfiles = []
for f in match._files:
fstandin = lfutil.standin(f)
# ignore known largefiles and standins
if f in lfiles or fstandin in standins:
continue
# append directory separator to avoid collisions
if not fstandin.endswith(os.sep):
fstandin += os.sep
# prevalidate matching standin directories
if util.any(st for st in match._files
if st.startswith(fstandin)):
continue
actualfiles.append(f)
match._files = actualfiles
def matchfn(f):
if orig_matchfn(f):
return f not in lfiles
else:
return f in standins
match.matchfn = matchfn
return orig(text=text, user=user, date=date, match=match,
force=force, editor=editor, extra=extra)
finally:
wlock.release()
def updatelfiles(ui, repo, filelist=None, printmessage=True,
normallookup=False):
wlock = repo.wlock()
try:
lfdirstate = lfutil.openlfdirstate(ui, repo)
lfiles = set(lfutil.listlfiles(repo)) | set(lfdirstate)
if filelist is not None:
filelist = set(filelist)
lfiles = [f for f in lfiles if f in filelist]
update = {}
updated, removed = 0, 0
for lfile in lfiles:
abslfile = repo.wjoin(lfile)
absstandin = repo.wjoin(lfutil.standin(lfile))
if os.path.exists(absstandin):
if (os.path.exists(absstandin + '.orig') and
os.path.exists(abslfile)):
shutil.copyfile(abslfile, abslfile + '.orig')
util.unlinkpath(absstandin + '.orig')
expecthash = lfutil.readstandin(repo, lfile)
if (expecthash != '' and
(not os.path.exists(abslfile) or
expecthash != lfutil.hashfile(abslfile))):
if lfile not in repo[None]: # not switched to normal file
util.unlinkpath(abslfile, ignoremissing=True)
# use normallookup() to allocate entry in largefiles
# dirstate, because lack of it misleads
# lfilesrepo.status() into recognition that such cache
# missing files are REMOVED.
lfdirstate.normallookup(lfile)
update[lfile] = expecthash
else:
# Remove lfiles for which the standin is deleted, unless the
# lfile is added to the repository again. This happens when a
# largefile is converted back to a normal file: the standin
# disappears, but a new (normal) file appears as the lfile.
if (os.path.exists(abslfile) and
repo.dirstate.normalize(lfile) not in repo[None]):
util.unlinkpath(abslfile)
removed += 1
# largefile processing might be slow and be interrupted - be prepared
lfdirstate.write()
if lfiles:
if printmessage:
ui.status(_('getting changed largefiles\n'))
cachelfiles(ui, repo, None, lfiles)
for lfile in lfiles:
update1 = 0
expecthash = update.get(lfile)
if expecthash:
if not lfutil.copyfromcache(repo, expecthash, lfile):
# failed ... but already removed and set to normallookup
continue
# Synchronize largefile dirstate to the last modified
# time of the file
lfdirstate.normal(lfile)
update1 = 1
# copy the state of largefile standin from the repository's
# dirstate to its state in the lfdirstate.
abslfile = repo.wjoin(lfile)
absstandin = repo.wjoin(lfutil.standin(lfile))
if os.path.exists(absstandin):
mode = os.stat(absstandin).st_mode
if mode != os.stat(abslfile).st_mode:
os.chmod(abslfile, mode)
update1 = 1
updated += update1
lfutil.synclfdirstate(repo, lfdirstate, lfile, normallookup)
if filelist is not None:
# If "local largefile" is chosen at file merging, it is
# not listed in "filelist" (= dirstate syncing is
# omitted), because the standin file is not changed before and
# after merging.
# But the status of such files may have to be changed by
# merging. For example, locally modified ("M") largefile
# has to become re-added("A"), if it is "normal" file in
# the target revision of linear-merging.
for lfile in lfdirstate:
if lfile not in filelist:
lfutil.synclfdirstate(repo, lfdirstate, lfile, True)
lfdirstate.write()
if printmessage and lfiles:
ui.status(_('%d largefiles updated, %d removed\n') % (updated,
removed))
finally:
wlock.release()
def updatelfiles(ui,
repo,
filelist=None,
printmessage=None,
normallookup=False):
'''Update largefiles according to standins in the working directory
If ``printmessage`` is other than ``None``, it means "print (or
ignore, for false) message forcibly".
'''
statuswriter = lfutil.getstatuswriter(ui, repo, printmessage)
with repo.wlock():
lfdirstate = lfutil.openlfdirstate(ui, repo)
lfiles = set(lfutil.listlfiles(repo)) | set(lfdirstate)
if filelist is not None:
filelist = set(filelist)
lfiles = [f for f in lfiles if f in filelist]
update = {}
updated, removed = 0, 0
wvfs = repo.wvfs
for lfile in lfiles:
rellfile = lfile
rellfileorig = os.path.relpath(scmutil.origpath(
ui, repo, wvfs.join(rellfile)),
start=repo.root)
relstandin = lfutil.standin(lfile)
relstandinorig = os.path.relpath(scmutil.origpath(
ui, repo, wvfs.join(relstandin)),
start=repo.root)
if wvfs.exists(relstandin):
if (wvfs.exists(relstandinorig) and wvfs.exists(rellfile)):
shutil.copyfile(wvfs.join(rellfile),
wvfs.join(rellfileorig))
wvfs.unlinkpath(relstandinorig)
expecthash = lfutil.readstandin(repo, lfile)
if expecthash != '':
if lfile not in repo[None]: # not switched to normal file
wvfs.unlinkpath(rellfile, ignoremissing=True)
# use normallookup() to allocate an entry in largefiles
# dirstate to prevent lfilesrepo.status() from reporting
# missing files as removed.
lfdirstate.normallookup(lfile)
update[lfile] = expecthash
else:
# Remove lfiles for which the standin is deleted, unless the
# lfile is added to the repository again. This happens when a
# largefile is converted back to a normal file: the standin
# disappears, but a new (normal) file appears as the lfile.
if (wvfs.exists(rellfile)
and repo.dirstate.normalize(lfile) not in repo[None]):
wvfs.unlinkpath(rellfile)
removed += 1
# largefile processing might be slow and be interrupted - be prepared
lfdirstate.write()
if lfiles:
statuswriter(_('getting changed largefiles\n'))
cachelfiles(ui, repo, None, lfiles)
for lfile in lfiles:
update1 = 0
expecthash = update.get(lfile)
if expecthash:
if not lfutil.copyfromcache(repo, expecthash, lfile):
# failed ... but already removed and set to normallookup
continue
# Synchronize largefile dirstate to the last modified
# time of the file
lfdirstate.normal(lfile)
update1 = 1
# copy the state of largefile standin from the repository's
# dirstate to its state in the lfdirstate.
rellfile = lfile
relstandin = lfutil.standin(lfile)
if wvfs.exists(relstandin):
mode = wvfs.stat(relstandin).st_mode
if mode != wvfs.stat(rellfile).st_mode:
wvfs.chmod(rellfile, mode)
update1 = 1
updated += update1
lfutil.synclfdirstate(repo, lfdirstate, lfile, normallookup)
lfdirstate.write()
if lfiles:
statuswriter(
_('%d largefiles updated, %d removed\n') % (updated, removed))
def updatelfiles(ui, repo, filelist=None, printmessage=None,
normallookup=False):
'''Update largefiles according to standins in the working directory
If ``printmessage`` is other than ``None``, it means "print (or
ignore, for false) message forcibly".
'''
statuswriter = lfutil.getstatuswriter(ui, repo, printmessage)
wlock = repo.wlock()
try:
lfdirstate = lfutil.openlfdirstate(ui, repo)
lfiles = set(lfutil.listlfiles(repo)) | set(lfdirstate)
if filelist is not None:
filelist = set(filelist)
lfiles = [f for f in lfiles if f in filelist]
update = {}
updated, removed = 0, 0
for lfile in lfiles:
abslfile = repo.wjoin(lfile)
absstandin = repo.wjoin(lfutil.standin(lfile))
if os.path.exists(absstandin):
if (os.path.exists(absstandin + '.orig') and
os.path.exists(abslfile)):
shutil.copyfile(abslfile, abslfile + '.orig')
util.unlinkpath(absstandin + '.orig')
expecthash = lfutil.readstandin(repo, lfile)
if expecthash != '':
if lfile not in repo[None]: # not switched to normal file
util.unlinkpath(abslfile, ignoremissing=True)
# use normallookup() to allocate an entry in largefiles
# dirstate to prevent lfilesrepo.status() from reporting
# missing files as removed.
lfdirstate.normallookup(lfile)
update[lfile] = expecthash
else:
# Remove lfiles for which the standin is deleted, unless the
# lfile is added to the repository again. This happens when a
# largefile is converted back to a normal file: the standin
# disappears, but a new (normal) file appears as the lfile.
if (os.path.exists(abslfile) and
repo.dirstate.normalize(lfile) not in repo[None]):
util.unlinkpath(abslfile)
removed += 1
# largefile processing might be slow and be interrupted - be prepared
lfdirstate.write()
if lfiles:
statuswriter(_('getting changed largefiles\n'))
cachelfiles(ui, repo, None, lfiles)
for lfile in lfiles:
update1 = 0
expecthash = update.get(lfile)
if expecthash:
if not lfutil.copyfromcache(repo, expecthash, lfile):
# failed ... but already removed and set to normallookup
continue
# Synchronize largefile dirstate to the last modified
# time of the file
lfdirstate.normal(lfile)
update1 = 1
# copy the state of largefile standin from the repository's
# dirstate to its state in the lfdirstate.
abslfile = repo.wjoin(lfile)
absstandin = repo.wjoin(lfutil.standin(lfile))
if os.path.exists(absstandin):
mode = os.stat(absstandin).st_mode
if mode != os.stat(abslfile).st_mode:
os.chmod(abslfile, mode)
update1 = 1
updated += update1
lfutil.synclfdirstate(repo, lfdirstate, lfile, normallookup)
lfdirstate.write()
if lfiles:
statuswriter(_('%d largefiles updated, %d removed\n') % (updated,
removed))
finally:
wlock.release()
def updatelfiles(ui,
repo,
filelist=None,
printmessage=True,
normallookup=False):
wlock = repo.wlock()
try:
lfdirstate = lfutil.openlfdirstate(ui, repo)
lfiles = set(lfutil.listlfiles(repo)) | set(lfdirstate)
if filelist is not None:
lfiles = [f for f in lfiles if f in filelist]
update = {}
updated, removed = 0, 0
for lfile in lfiles:
abslfile = repo.wjoin(lfile)
absstandin = repo.wjoin(lfutil.standin(lfile))
if os.path.exists(absstandin):
if (os.path.exists(absstandin + '.orig')
and os.path.exists(abslfile)):
shutil.copyfile(abslfile, abslfile + '.orig')
util.unlinkpath(absstandin + '.orig')
expecthash = lfutil.readstandin(repo, lfile)
if (expecthash != ''
and (not os.path.exists(abslfile)
or expecthash != lfutil.hashfile(abslfile))):
if lfile not in repo[None]: # not switched to normal file
util.unlinkpath(abslfile, ignoremissing=True)
# use normallookup() to allocate entry in largefiles
# dirstate, because lack of it misleads
# lfilesrepo.status() into recognition that such cache
# missing files are REMOVED.
lfdirstate.normallookup(lfile)
update[lfile] = expecthash
else:
# Remove lfiles for which the standin is deleted, unless the
# lfile is added to the repository again. This happens when a
# largefile is converted back to a normal file: the standin
# disappears, but a new (normal) file appears as the lfile.
if (os.path.exists(abslfile)
and repo.dirstate.normalize(lfile) not in repo[None]):
util.unlinkpath(abslfile)
removed += 1
# largefile processing might be slow and be interrupted - be prepared
lfdirstate.write()
if lfiles:
if printmessage:
ui.status(_('getting changed largefiles\n'))
cachelfiles(ui, repo, None, lfiles)
for lfile in lfiles:
update1 = 0
expecthash = update.get(lfile)
if expecthash:
if not lfutil.copyfromcache(repo, expecthash, lfile):
# failed ... but already removed and set to normallookup
continue
# Synchronize largefile dirstate to the last modified
# time of the file
lfdirstate.normal(lfile)
update1 = 1
# copy the state of largefile standin from the repository's
# dirstate to its state in the lfdirstate.
abslfile = repo.wjoin(lfile)
absstandin = repo.wjoin(lfutil.standin(lfile))
if os.path.exists(absstandin):
mode = os.stat(absstandin).st_mode
if mode != os.stat(abslfile).st_mode:
os.chmod(abslfile, mode)
update1 = 1
updated += update1
standin = lfutil.standin(lfile)
if standin in repo.dirstate:
stat = repo.dirstate._map[standin]
state, mtime = stat[0], stat[3]
else:
state, mtime = '?', -1
if state == 'n':
if normallookup or mtime < 0:
# state 'n' doesn't ensure 'clean' in this case
lfdirstate.normallookup(lfile)
else:
lfdirstate.normal(lfile)
elif state == 'm':
lfdirstate.normallookup(lfile)
elif state == 'r':
lfdirstate.remove(lfile)
elif state == 'a':
lfdirstate.add(lfile)
elif state == '?':
lfdirstate.drop(lfile)
lfdirstate.write()
if printmessage and lfiles:
ui.status(
_('%d largefiles updated, %d removed\n') % (updated, removed))
finally:
wlock.release()
def commit(self,
text="",
user=None,
date=None,
match=None,
force=False,
editor=False,
extra={}):
orig = super(lfilesrepo, self).commit
wlock = self.wlock()
try:
# Case 0: Automated committing
#
# While automated committing (like rebase, transplant
# and so on), this code path is used to avoid:
# (1) updating standins, because standins should
# be already updated at this point
# (2) aborting when stadnins are matched by "match",
# because automated committing may specify them directly
#
if getattr(self, "_isrebasing", False) or \
getattr(self, "_istransplanting", False):
result = orig(text=text,
user=user,
date=date,
match=match,
force=force,
editor=editor,
extra=extra)
if result:
lfdirstate = lfutil.openlfdirstate(ui, self)
for f in self[result].files():
if lfutil.isstandin(f):
lfile = lfutil.splitstandin(f)
lfutil.synclfdirstate(self, lfdirstate, lfile,
False)
lfdirstate.write()
return result
# Case 1: user calls commit with no specific files or
# include/exclude patterns: refresh and commit all files that
# are "dirty".
if ((match is None)
or (not match.anypats() and not match.files())):
# Spend a bit of time here to get a list of files we know
# are modified so we can compare only against those.
# It can cost a lot of time (several seconds)
# otherwise to update all standins if the largefiles are
# large.
lfdirstate = lfutil.openlfdirstate(ui, self)
dirtymatch = match_.always(self.root, self.getcwd())
unsure, s = lfdirstate.status(dirtymatch, [], False, False,
False)
modifiedfiles = unsure + s.modified + s.added + s.removed
lfiles = lfutil.listlfiles(self)
# this only loops through largefiles that exist (not
# removed/renamed)
for lfile in lfiles:
if lfile in modifiedfiles:
if os.path.exists(self.wjoin(
lfutil.standin(lfile))):
# this handles the case where a rebase is being
# performed and the working copy is not updated
# yet.
if os.path.exists(self.wjoin(lfile)):
lfutil.updatestandin(
self, lfutil.standin(lfile))
lfdirstate.normal(lfile)
result = orig(text=text,
user=user,
date=date,
match=match,
force=force,
editor=editor,
extra=extra)
if result is not None:
for lfile in lfdirstate:
if lfile in modifiedfiles:
if (not os.path.exists(self.wjoin(
lfutil.standin(lfile)))) or \
(not os.path.exists(self.wjoin(lfile))):
lfdirstate.drop(lfile)
# This needs to be after commit; otherwise precommit hooks
# get the wrong status
lfdirstate.write()
return result
lfiles = lfutil.listlfiles(self)
match._files = self._subdirlfs(match.files(), lfiles)
# Case 2: user calls commit with specified patterns: refresh
# any matching big files.
smatcher = lfutil.composestandinmatcher(self, match)
standins = self.dirstate.walk(smatcher, [], False, False)
# No matching big files: get out of the way and pass control to
# the usual commit() method.
if not standins:
return orig(text=text,
user=user,
date=date,
match=match,
force=force,
editor=editor,
extra=extra)
# Refresh all matching big files. It's possible that the
# commit will end up failing, in which case the big files will
# stay refreshed. No harm done: the user modified them and
# asked to commit them, so sooner or later we're going to
# refresh the standins. Might as well leave them refreshed.
lfdirstate = lfutil.openlfdirstate(ui, self)
for standin in standins:
lfile = lfutil.splitstandin(standin)
if lfdirstate[lfile] != 'r':
lfutil.updatestandin(self, standin)
lfdirstate.normal(lfile)
else:
lfdirstate.drop(lfile)
# Cook up a new matcher that only matches regular files or
# standins corresponding to the big files requested by the
# user. Have to modify _files to prevent commit() from
# complaining "not tracked" for big files.
match = copy.copy(match)
origmatchfn = match.matchfn
# Check both the list of largefiles and the list of
# standins because if a largefile was removed, it
# won't be in the list of largefiles at this point
match._files += sorted(standins)
actualfiles = []
for f in match._files:
fstandin = lfutil.standin(f)
# ignore known largefiles and standins
if f in lfiles or fstandin in standins:
continue
actualfiles.append(f)
match._files = actualfiles
def matchfn(f):
if origmatchfn(f):
return f not in lfiles
else:
return f in standins
match.matchfn = matchfn
result = orig(text=text,
user=user,
date=date,
match=match,
force=force,
editor=editor,
extra=extra)
# This needs to be after commit; otherwise precommit hooks
# get the wrong status
lfdirstate.write()
return result
finally:
wlock.release()
def commit(self, text="", user=None, date=None, match=None, force=False, editor=False, extra={}):
orig = super(lfilesrepo, self).commit
wlock = self.wlock()
try:
# Case 0: Automated committing
#
# While automated committing (like rebase, transplant
# and so on), this code path is used to avoid:
# (1) updating standins, because standins should
# be already updated at this point
# (2) aborting when stadnins are matched by "match",
# because automated committing may specify them directly
#
if getattr(self, "_isrebasing", False) or getattr(self, "_istransplanting", False):
result = orig(text=text, user=user, date=date, match=match, force=force, editor=editor, extra=extra)
if result:
lfdirstate = lfutil.openlfdirstate(ui, self)
for f in self[result].files():
if lfutil.isstandin(f):
lfile = lfutil.splitstandin(f)
lfutil.synclfdirstate(self, lfdirstate, lfile, False)
lfdirstate.write()
return result
# Case 1: user calls commit with no specific files or
# include/exclude patterns: refresh and commit all files that
# are "dirty".
if (match is None) or (not match.anypats() and not match.files()):
# Spend a bit of time here to get a list of files we know
# are modified so we can compare only against those.
# It can cost a lot of time (several seconds)
# otherwise to update all standins if the largefiles are
# large.
lfdirstate = lfutil.openlfdirstate(ui, self)
dirtymatch = match_.always(self.root, self.getcwd())
unsure, s = lfdirstate.status(dirtymatch, [], False, False, False)
modifiedfiles = unsure + s.modified + s.added + s.removed
lfiles = lfutil.listlfiles(self)
# this only loops through largefiles that exist (not
# removed/renamed)
for lfile in lfiles:
if lfile in modifiedfiles:
if os.path.exists(self.wjoin(lfutil.standin(lfile))):
# this handles the case where a rebase is being
# performed and the working copy is not updated
# yet.
if os.path.exists(self.wjoin(lfile)):
lfutil.updatestandin(self, lfutil.standin(lfile))
lfdirstate.normal(lfile)
result = orig(text=text, user=user, date=date, match=match, force=force, editor=editor, extra=extra)
if result is not None:
for lfile in lfdirstate:
if lfile in modifiedfiles:
if (not os.path.exists(self.wjoin(lfutil.standin(lfile)))) or (
not os.path.exists(self.wjoin(lfile))
):
lfdirstate.drop(lfile)
# This needs to be after commit; otherwise precommit hooks
# get the wrong status
lfdirstate.write()
return result
lfiles = lfutil.listlfiles(self)
match._files = self._subdirlfs(match.files(), lfiles)
# Case 2: user calls commit with specified patterns: refresh
# any matching big files.
smatcher = lfutil.composestandinmatcher(self, match)
standins = self.dirstate.walk(smatcher, [], False, False)
# No matching big files: get out of the way and pass control to
# the usual commit() method.
if not standins:
return orig(text=text, user=user, date=date, match=match, force=force, editor=editor, extra=extra)
# Refresh all matching big files. It's possible that the
# commit will end up failing, in which case the big files will
# stay refreshed. No harm done: the user modified them and
# asked to commit them, so sooner or later we're going to
# refresh the standins. Might as well leave them refreshed.
lfdirstate = lfutil.openlfdirstate(ui, self)
for standin in standins:
lfile = lfutil.splitstandin(standin)
if lfdirstate[lfile] != "r":
lfutil.updatestandin(self, standin)
lfdirstate.normal(lfile)
else:
lfdirstate.drop(lfile)
# Cook up a new matcher that only matches regular files or
# standins corresponding to the big files requested by the
# user. Have to modify _files to prevent commit() from
# complaining "not tracked" for big files.
match = copy.copy(match)
origmatchfn = match.matchfn
# Check both the list of largefiles and the list of
# standins because if a largefile was removed, it
# won't be in the list of largefiles at this point
match._files += sorted(standins)
actualfiles = []
for f in match._files:
fstandin = lfutil.standin(f)
# ignore known largefiles and standins
if f in lfiles or fstandin in standins:
continue
actualfiles.append(f)
match._files = actualfiles
def matchfn(f):
if origmatchfn(f):
return f not in lfiles
else:
return f in standins
match.matchfn = matchfn
result = orig(text=text, user=user, date=date, match=match, force=force, editor=editor, extra=extra)
# This needs to be after commit; otherwise precommit hooks
# get the wrong status
lfdirstate.write()
return result
finally:
wlock.release()
def commit(self, text="", user=None, date=None, match=None,
force=False, editor=False, extra={}):
orig = super(lfilesrepo, self).commit
wlock = repo.wlock()
try:
# Case 0: Rebase or Transplant
# We have to take the time to pull down the new largefiles now.
# Otherwise, any largefiles that were modified in the
# destination changesets get overwritten, either by the rebase
# or in the first commit after the rebase or transplant.
# updatelfiles will update the dirstate to mark any pulled
# largefiles as modified
if getattr(repo, "_isrebasing", False) or \
getattr(repo, "_istransplanting", False):
lfcommands.updatelfiles(repo.ui, repo, filelist=None,
printmessage=False)
result = orig(text=text, user=user, date=date, match=match,
force=force, editor=editor, extra=extra)
return result
# Case 1: user calls commit with no specific files or
# include/exclude patterns: refresh and commit all files that
# are "dirty".
if ((match is None) or
(not match.anypats() and not match.files())):
# Spend a bit of time here to get a list of files we know
# are modified so we can compare only against those.
# It can cost a lot of time (several seconds)
# otherwise to update all standins if the largefiles are
# large.
lfdirstate = lfutil.openlfdirstate(ui, self)
dirtymatch = match_.always(repo.root, repo.getcwd())
s = lfdirstate.status(dirtymatch, [], False, False, False)
modifiedfiles = []
for i in s:
modifiedfiles.extend(i)
lfiles = lfutil.listlfiles(self)
# this only loops through largefiles that exist (not
# removed/renamed)
for lfile in lfiles:
if lfile in modifiedfiles:
if os.path.exists(
self.wjoin(lfutil.standin(lfile))):
# this handles the case where a rebase is being
# performed and the working copy is not updated
# yet.
if os.path.exists(self.wjoin(lfile)):
lfutil.updatestandin(self,
lfutil.standin(lfile))
lfdirstate.normal(lfile)
for lfile in lfdirstate:
if lfile in modifiedfiles:
if not os.path.exists(
repo.wjoin(lfutil.standin(lfile))):
lfdirstate.drop(lfile)
result = orig(text=text, user=user, date=date, match=match,
force=force, editor=editor, extra=extra)
# This needs to be after commit; otherwise precommit hooks
# get the wrong status
lfdirstate.write()
return result
for f in match.files():
if lfutil.isstandin(f):
raise util.Abort(
_('file "%s" is a largefile standin') % f,
hint=('commit the largefile itself instead'))
# Case 2: user calls commit with specified patterns: refresh
# any matching big files.
smatcher = lfutil.composestandinmatcher(self, match)
standins = lfutil.dirstatewalk(self.dirstate, smatcher)
# No matching big files: get out of the way and pass control to
# the usual commit() method.
if not standins:
return orig(text=text, user=user, date=date, match=match,
force=force, editor=editor, extra=extra)
# Refresh all matching big files. It's possible that the
# commit will end up failing, in which case the big files will
# stay refreshed. No harm done: the user modified them and
# asked to commit them, so sooner or later we're going to
# refresh the standins. Might as well leave them refreshed.
lfdirstate = lfutil.openlfdirstate(ui, self)
for standin in standins:
lfile = lfutil.splitstandin(standin)
if lfdirstate[lfile] <> 'r':
lfutil.updatestandin(self, standin)
lfdirstate.normal(lfile)
else:
lfdirstate.drop(lfile)
# Cook up a new matcher that only matches regular files or
# standins corresponding to the big files requested by the
# user. Have to modify _files to prevent commit() from
# complaining "not tracked" for big files.
lfiles = lfutil.listlfiles(repo)
match = copy.copy(match)
origmatchfn = match.matchfn
# Check both the list of largefiles and the list of
# standins because if a largefile was removed, it
# won't be in the list of largefiles at this point
match._files += sorted(standins)
actualfiles = []
for f in match._files:
fstandin = lfutil.standin(f)
# ignore known largefiles and standins
if f in lfiles or fstandin in standins:
continue
# append directory separator to avoid collisions
if not fstandin.endswith(os.sep):
fstandin += os.sep
actualfiles.append(f)
match._files = actualfiles
def matchfn(f):
if origmatchfn(f):
return f not in lfiles
else:
return f in standins
match.matchfn = matchfn
result = orig(text=text, user=user, date=date, match=match,
force=force, editor=editor, extra=extra)
# This needs to be after commit; otherwise precommit hooks
# get the wrong status
lfdirstate.write()
return result
finally:
wlock.release()
def updatelfiles(ui,
repo,
filelist=None,
printmessage=True,
normallookup=False):
wlock = repo.wlock()
try:
lfdirstate = lfutil.openlfdirstate(ui, repo)
lfiles = set(lfutil.listlfiles(repo)) | set(lfdirstate)
if filelist is not None:
filelist = set(filelist)
lfiles = [f for f in lfiles if f in filelist]
update = {}
updated, removed = 0, 0
for lfile in lfiles:
abslfile = repo.wjoin(lfile)
absstandin = repo.wjoin(lfutil.standin(lfile))
if os.path.exists(absstandin):
if (os.path.exists(absstandin + '.orig')
and os.path.exists(abslfile)):
shutil.copyfile(abslfile, abslfile + '.orig')
util.unlinkpath(absstandin + '.orig')
expecthash = lfutil.readstandin(repo, lfile)
if (expecthash != ''
and (not os.path.exists(abslfile)
or expecthash != lfutil.hashfile(abslfile))):
if lfile not in repo[None]: # not switched to normal file
util.unlinkpath(abslfile, ignoremissing=True)
# use normallookup() to allocate entry in largefiles
# dirstate, because lack of it misleads
# lfilesrepo.status() into recognition that such cache
# missing files are REMOVED.
lfdirstate.normallookup(lfile)
update[lfile] = expecthash
else:
# Remove lfiles for which the standin is deleted, unless the
# lfile is added to the repository again. This happens when a
# largefile is converted back to a normal file: the standin
# disappears, but a new (normal) file appears as the lfile.
if (os.path.exists(abslfile)
and repo.dirstate.normalize(lfile) not in repo[None]):
util.unlinkpath(abslfile)
removed += 1
# largefile processing might be slow and be interrupted - be prepared
lfdirstate.write()
if lfiles:
if printmessage:
ui.status(_('getting changed largefiles\n'))
cachelfiles(ui, repo, None, lfiles)
for lfile in lfiles:
update1 = 0
expecthash = update.get(lfile)
if expecthash:
if not lfutil.copyfromcache(repo, expecthash, lfile):
# failed ... but already removed and set to normallookup
continue
# Synchronize largefile dirstate to the last modified
# time of the file
lfdirstate.normal(lfile)
update1 = 1
# copy the state of largefile standin from the repository's
# dirstate to its state in the lfdirstate.
abslfile = repo.wjoin(lfile)
absstandin = repo.wjoin(lfutil.standin(lfile))
if os.path.exists(absstandin):
mode = os.stat(absstandin).st_mode
if mode != os.stat(abslfile).st_mode:
os.chmod(abslfile, mode)
update1 = 1
updated += update1
lfutil.synclfdirstate(repo, lfdirstate, lfile, normallookup)
if filelist is not None:
# If "local largefile" is chosen at file merging, it is
# not listed in "filelist" (= dirstate syncing is
# omitted), because the standin file is not changed before and
# after merging.
# But the status of such files may have to be changed by
# merging. For example, locally modified ("M") largefile
# has to become re-added("A"), if it is "normal" file in
# the target revision of linear-merging.
for lfile in lfdirstate:
if lfile not in filelist:
lfutil.synclfdirstate(repo, lfdirstate, lfile, True)
lfdirstate.write()
if printmessage and lfiles:
ui.status(
_('%d largefiles updated, %d removed\n') % (updated, removed))
finally:
wlock.release()
def commit(self, text="", user=None, date=None, match=None,
force=False, editor=False, extra={}):
orig = super(lfilesrepo, self).commit
wlock = self.wlock()
try:
# Case 0: Rebase or Transplant
# We have to take the time to pull down the new largefiles now.
# Otherwise, any largefiles that were modified in the
# destination changesets get overwritten, either by the rebase
# or in the first commit after the rebase or transplant.
# updatelfiles will update the dirstate to mark any pulled
# largefiles as modified
if getattr(self, "_isrebasing", False) or \
getattr(self, "_istransplanting", False):
lfcommands.updatelfiles(self.ui, self, filelist=None,
printmessage=False)
result = orig(text=text, user=user, date=date, match=match,
force=force, editor=editor, extra=extra)
return result
# Case 1: user calls commit with no specific files or
# include/exclude patterns: refresh and commit all files that
# are "dirty".
if ((match is None) or
(not match.anypats() and not match.files())):
# Spend a bit of time here to get a list of files we know
# are modified so we can compare only against those.
# It can cost a lot of time (several seconds)
# otherwise to update all standins if the largefiles are
# large.
lfdirstate = lfutil.openlfdirstate(ui, self)
dirtymatch = match_.always(self.root, self.getcwd())
s = lfdirstate.status(dirtymatch, [], False, False, False)
(unsure, modified, added, removed, _missing, _unknown,
_ignored, _clean) = s
modifiedfiles = unsure + modified + added + removed
lfiles = lfutil.listlfiles(self)
# this only loops through largefiles that exist (not
# removed/renamed)
for lfile in lfiles:
if lfile in modifiedfiles:
if os.path.exists(
self.wjoin(lfutil.standin(lfile))):
# this handles the case where a rebase is being
# performed and the working copy is not updated
# yet.
if os.path.exists(self.wjoin(lfile)):
lfutil.updatestandin(self,
lfutil.standin(lfile))
lfdirstate.normal(lfile)
result = orig(text=text, user=user, date=date, match=match,
force=force, editor=editor, extra=extra)
if result is not None:
for lfile in lfdirstate:
if lfile in modifiedfiles:
if (not os.path.exists(self.wjoin(
lfutil.standin(lfile)))) or \
(not os.path.exists(self.wjoin(lfile))):
lfdirstate.drop(lfile)
# This needs to be after commit; otherwise precommit hooks
# get the wrong status
lfdirstate.write()
return result
lfiles = lfutil.listlfiles(self)
match._files = self._subdirlfs(match.files(), lfiles)
# Case 2: user calls commit with specified patterns: refresh
# any matching big files.
smatcher = lfutil.composestandinmatcher(self, match)
standins = self.dirstate.walk(smatcher, [], False, False)
# No matching big files: get out of the way and pass control to
# the usual commit() method.
if not standins:
return orig(text=text, user=user, date=date, match=match,
force=force, editor=editor, extra=extra)
# Refresh all matching big files. It's possible that the
# commit will end up failing, in which case the big files will
# stay refreshed. No harm done: the user modified them and
# asked to commit them, so sooner or later we're going to
# refresh the standins. Might as well leave them refreshed.
lfdirstate = lfutil.openlfdirstate(ui, self)
for standin in standins:
lfile = lfutil.splitstandin(standin)
if lfdirstate[lfile] != 'r':
lfutil.updatestandin(self, standin)
lfdirstate.normal(lfile)
else:
lfdirstate.drop(lfile)
# Cook up a new matcher that only matches regular files or
# standins corresponding to the big files requested by the
# user. Have to modify _files to prevent commit() from
# complaining "not tracked" for big files.
match = copy.copy(match)
origmatchfn = match.matchfn
# Check both the list of largefiles and the list of
# standins because if a largefile was removed, it
# won't be in the list of largefiles at this point
match._files += sorted(standins)
actualfiles = []
for f in match._files:
fstandin = lfutil.standin(f)
# ignore known largefiles and standins
if f in lfiles or fstandin in standins:
continue
# append directory separator to avoid collisions
if not fstandin.endswith(os.sep):
fstandin += os.sep
actualfiles.append(f)
match._files = actualfiles
def matchfn(f):
if origmatchfn(f):
return f not in lfiles
else:
return f in standins
match.matchfn = matchfn
result = orig(text=text, user=user, date=date, match=match,
force=force, editor=editor, extra=extra)
# This needs to be after commit; otherwise precommit hooks
# get the wrong status
lfdirstate.write()
return result
finally:
wlock.release()
def updatelfiles(ui, repo, filelist=None, printmessage=True):
wlock = repo.wlock()
try:
lfdirstate = lfutil.openlfdirstate(ui, repo)
lfiles = set(lfutil.listlfiles(repo)) | set(lfdirstate)
if filelist is not None:
lfiles = [f for f in lfiles if f in filelist]
update = {}
updated, removed = 0, 0
for lfile in lfiles:
abslfile = repo.wjoin(lfile)
absstandin = repo.wjoin(lfutil.standin(lfile))
if os.path.exists(absstandin):
if (os.path.exists(absstandin + '.orig') and
os.path.exists(abslfile)):
shutil.copyfile(abslfile, abslfile + '.orig')
expecthash = lfutil.readstandin(repo, lfile)
if (expecthash != '' and
(not os.path.exists(abslfile) or
expecthash != lfutil.hashfile(abslfile))):
if lfile not in repo[None]: # not switched to normal file
util.unlinkpath(abslfile, ignoremissing=True)
# use normallookup() to allocate entry in largefiles
# dirstate, because lack of it misleads
# lfilesrepo.status() into recognition that such cache
# missing files are REMOVED.
lfdirstate.normallookup(lfile)
update[lfile] = expecthash
else:
# Remove lfiles for which the standin is deleted, unless the
# lfile is added to the repository again. This happens when a
# largefile is converted back to a normal file: the standin
# disappears, but a new (normal) file appears as the lfile.
if (os.path.exists(abslfile) and
repo.dirstate.normalize(lfile) not in repo[None]):
util.unlinkpath(abslfile)
removed += 1
# largefile processing might be slow and be interrupted - be prepared
lfdirstate.write()
if lfiles:
if printmessage:
ui.status(_('getting changed largefiles\n'))
cachelfiles(ui, repo, None, lfiles)
for lfile in lfiles:
update1 = 0
expecthash = update.get(lfile)
if expecthash:
if not lfutil.copyfromcache(repo, expecthash, lfile):
# failed ... but already removed and set to normallookup
continue
# Synchronize largefile dirstate to the last modified
# time of the file
lfdirstate.normal(lfile)
update1 = 1
# copy the state of largefile standin from the repository's
# dirstate to its state in the lfdirstate.
abslfile = repo.wjoin(lfile)
absstandin = repo.wjoin(lfutil.standin(lfile))
if os.path.exists(absstandin):
mode = os.stat(absstandin).st_mode
if mode != os.stat(abslfile).st_mode:
os.chmod(abslfile, mode)
update1 = 1
updated += update1
state = repo.dirstate[lfutil.standin(lfile)]
if state == 'n':
# When rebasing, we need to synchronize the standin and the
# largefile, because otherwise the largefile will get reverted.
# But for commit's sake, we have to mark the file as unclean.
if getattr(repo, "_isrebasing", False):
lfdirstate.normallookup(lfile)
else:
lfdirstate.normal(lfile)
elif state == 'r':
lfdirstate.remove(lfile)
elif state == 'a':
lfdirstate.add(lfile)
elif state == '?':
lfdirstate.drop(lfile)
lfdirstate.write()
if printmessage and lfiles:
ui.status(_('%d largefiles updated, %d removed\n') % (updated,
removed))
finally:
wlock.release()