largefiles: respect the rev when reading standins in copytostore() (issue3630)

When the rev isn't specified, the standin for the working copy gets read.  But
convert doesn't update the working copy for each cset it processes, so there is
no standin and the 'hg convert' would abort complaining about the standin being
missing.

Note that if the largefile is not in the user cache, 'hg convert' complains
about the largefile itself missing from the destination repo.

hgext/largefiles/lfutil.py

@@ -1,469 +1,469 b''
 # 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.
 
 '''largefiles utility code: must not import other modules in this package.'''
 
 import os
 import errno
 import platform
 import shutil
 import stat
 
 from mercurial import dirstate, httpconnection, match as match_, util, scmutil
 from mercurial.i18n import _
 
 shortname = '.hglf'
 longname = 'largefiles'
 
 
 # -- Portability wrappers ----------------------------------------------
 
 def dirstatewalk(dirstate, matcher, unknown=False, ignored=False):
     return dirstate.walk(matcher, [], unknown, ignored)
 
 def repoadd(repo, list):
     add = repo[None].add
     return add(list)
 
 def reporemove(repo, list, unlink=False):
     def remove(list, unlink):
         wlock = repo.wlock()
         try:
             if unlink:
                 for f in list:
                     try:
                         util.unlinkpath(repo.wjoin(f))
                     except OSError, inst:
                         if inst.errno != errno.ENOENT:
                             raise
             repo[None].forget(list)
         finally:
             wlock.release()
     return remove(list, unlink=unlink)
 
 def repoforget(repo, list):
     forget = repo[None].forget
     return forget(list)
 
 def findoutgoing(repo, remote, force):
     from mercurial import discovery
     outgoing = discovery.findcommonoutgoing(repo, remote.peer(), force=force)
     return outgoing.missing
 
 # -- Private worker functions ------------------------------------------
 
 def getminsize(ui, assumelfiles, opt, default=10):
     lfsize = opt
     if not lfsize and assumelfiles:
         lfsize = ui.config(longname, 'minsize', default=default)
     if lfsize:
         try:
             lfsize = float(lfsize)
         except ValueError:
             raise util.Abort(_('largefiles: size must be number (not %s)\n')
                              % lfsize)
     if lfsize is None:
         raise util.Abort(_('minimum size for largefiles must be specified'))
     return lfsize
 
 def link(src, dest):
     try:
         util.oslink(src, dest)
     except OSError:
         # if hardlinks fail, fallback on atomic copy
         dst = util.atomictempfile(dest)
         for chunk in util.filechunkiter(open(src, 'rb')):
             dst.write(chunk)
         dst.close()
         os.chmod(dest, os.stat(src).st_mode)
 
 def usercachepath(ui, hash):
     path = ui.configpath(longname, 'usercache', None)
     if path:
         path = os.path.join(path, hash)
     else:
         if os.name == 'nt':
             appdata = os.getenv('LOCALAPPDATA', os.getenv('APPDATA'))
             if appdata:
                 path = os.path.join(appdata, longname, hash)
         elif platform.system() == 'Darwin':
             home = os.getenv('HOME')
             if home:
                 path = os.path.join(home, 'Library', 'Caches',
                                     longname, hash)
         elif os.name == 'posix':
             path = os.getenv('XDG_CACHE_HOME')
             if path:
                 path = os.path.join(path, longname, hash)
             else:
                 home = os.getenv('HOME')
                 if home:
                     path = os.path.join(home, '.cache', longname, hash)
         else:
             raise util.Abort(_('unknown operating system: %s\n') % os.name)
     return path
 
 def inusercache(ui, hash):
     path = usercachepath(ui, hash)
     return path and os.path.exists(path)
 
 def findfile(repo, hash):
     if instore(repo, hash):
         repo.ui.note(_('found %s in store\n') % hash)
         return storepath(repo, hash)
     elif inusercache(repo.ui, hash):
         repo.ui.note(_('found %s in system cache\n') % hash)
         path = storepath(repo, hash)
         util.makedirs(os.path.dirname(path))
         link(usercachepath(repo.ui, hash), path)
         return path
     return None
 
 class largefilesdirstate(dirstate.dirstate):
     def __getitem__(self, key):
         return super(largefilesdirstate, self).__getitem__(unixpath(key))
     def normal(self, f):
         return super(largefilesdirstate, self).normal(unixpath(f))
     def remove(self, f):
         return super(largefilesdirstate, self).remove(unixpath(f))
     def add(self, f):
         return super(largefilesdirstate, self).add(unixpath(f))
     def drop(self, f):
         return super(largefilesdirstate, self).drop(unixpath(f))
     def forget(self, f):
         return super(largefilesdirstate, self).forget(unixpath(f))
     def normallookup(self, f):
         return super(largefilesdirstate, self).normallookup(unixpath(f))
 
 def openlfdirstate(ui, repo, create=True):
     '''
     Return a dirstate object that tracks largefiles: i.e. its root is
     the repo root, but it is saved in .hg/largefiles/dirstate.
     '''
     admin = repo.join(longname)
     opener = scmutil.opener(admin)
     lfdirstate = largefilesdirstate(opener, ui, repo.root,
                                      repo.dirstate._validate)
 
     # If the largefiles dirstate does not exist, populate and create
     # it. This ensures that we create it on the first meaningful
     # largefiles operation in a new clone.
     if create and not os.path.exists(os.path.join(admin, 'dirstate')):
         util.makedirs(admin)
         matcher = getstandinmatcher(repo)
         for standin in dirstatewalk(repo.dirstate, matcher):
             lfile = splitstandin(standin)
             hash = readstandin(repo, lfile)
             lfdirstate.normallookup(lfile)
             try:
                 if hash == hashfile(repo.wjoin(lfile)):
                     lfdirstate.normal(lfile)
             except OSError, err:
                 if err.errno != errno.ENOENT:
                     raise
     return lfdirstate
 
 def lfdirstatestatus(lfdirstate, repo, rev):
     match = match_.always(repo.root, repo.getcwd())
     s = lfdirstate.status(match, [], False, False, False)
     unsure, modified, added, removed, missing, unknown, ignored, clean = s
     for lfile in unsure:
         if repo[rev][standin(lfile)].data().strip() != \
                 hashfile(repo.wjoin(lfile)):
             modified.append(lfile)
         else:
             clean.append(lfile)
             lfdirstate.normal(lfile)
     return (modified, added, removed, missing, unknown, ignored, clean)
 
 def listlfiles(repo, rev=None, matcher=None):
     '''return a list of largefiles in the working copy or the
     specified changeset'''
 
     if matcher is None:
         matcher = getstandinmatcher(repo)
 
     # ignore unknown files in working directory
     return [splitstandin(f)
             for f in repo[rev].walk(matcher)
             if rev is not None or repo.dirstate[f] != '?']
 
 def instore(repo, hash):
     return os.path.exists(storepath(repo, hash))
 
 def storepath(repo, hash):
     return repo.join(os.path.join(longname, hash))
 
 def copyfromcache(repo, hash, filename):
     '''Copy the specified largefile from the repo or system cache to
     filename in the repository. Return true on success or false if the
     file was not found in either cache (which should not happened:
     this is meant to be called only after ensuring that the needed
     largefile exists in the cache).'''
     path = findfile(repo, hash)
     if path is None:
         return False
     util.makedirs(os.path.dirname(repo.wjoin(filename)))
     # The write may fail before the file is fully written, but we
     # don't use atomic writes in the working copy.
     shutil.copy(path, repo.wjoin(filename))
     return True
 
 def copytostore(repo, rev, file, uploaded=False):
-    hash = readstandin(repo, file)
+    hash = readstandin(repo, file, rev)
     if instore(repo, hash):
         return
     copytostoreabsolute(repo, repo.wjoin(file), hash)
 
 def copyalltostore(repo, node):
     '''Copy all largefiles in a given revision to the store'''
 
     ctx = repo[node]
     for filename in ctx.files():
         if isstandin(filename) and filename in ctx.manifest():
             realfile = splitstandin(filename)
             copytostore(repo, ctx.node(), realfile)
 
 
 def copytostoreabsolute(repo, file, hash):
     util.makedirs(os.path.dirname(storepath(repo, hash)))
     if inusercache(repo.ui, hash):
         link(usercachepath(repo.ui, hash), storepath(repo, hash))
     else:
         dst = util.atomictempfile(storepath(repo, hash),
                                   createmode=repo.store.createmode)
         for chunk in util.filechunkiter(open(file, 'rb')):
             dst.write(chunk)
         dst.close()
         linktousercache(repo, hash)
 
 def linktousercache(repo, hash):
     path = usercachepath(repo.ui, hash)
     if path:
         util.makedirs(os.path.dirname(path))
         link(storepath(repo, hash), path)
 
 def getstandinmatcher(repo, pats=[], opts={}):
     '''Return a match object that applies pats to the standin directory'''
     standindir = repo.pathto(shortname)
     if pats:
         # patterns supplied: search standin directory relative to current dir
         cwd = repo.getcwd()
         if os.path.isabs(cwd):
             # cwd is an absolute path for hg -R <reponame>
             # work relative to the repository root in this case
             cwd = ''
         pats = [os.path.join(standindir, cwd, pat) for pat in pats]
     elif os.path.isdir(standindir):
         # no patterns: relative to repo root
         pats = [standindir]
     else:
         # no patterns and no standin dir: return matcher that matches nothing
         match = match_.match(repo.root, None, [], exact=True)
         match.matchfn = lambda f: False
         return match
     return getmatcher(repo, pats, opts, showbad=False)
 
 def getmatcher(repo, pats=[], opts={}, showbad=True):
     '''Wrapper around scmutil.match() that adds showbad: if false,
     neuter the match object's bad() method so it does not print any
     warnings about missing files or directories.'''
     match = scmutil.match(repo[None], pats, opts)
 
     if not showbad:
         match.bad = lambda f, msg: None
     return match
 
 def composestandinmatcher(repo, rmatcher):
     '''Return a matcher that accepts standins corresponding to the
     files accepted by rmatcher. Pass the list of files in the matcher
     as the paths specified by the user.'''
     smatcher = getstandinmatcher(repo, rmatcher.files())
     isstandin = smatcher.matchfn
     def composedmatchfn(f):
         return isstandin(f) and rmatcher.matchfn(splitstandin(f))
     smatcher.matchfn = composedmatchfn
 
     return smatcher
 
 def standin(filename):
     '''Return the repo-relative path to the standin for the specified big
     file.'''
     # Notes:
     # 1) Some callers want an absolute path, but for instance addlargefiles
     #    needs it repo-relative so it can be passed to repoadd().  So leave
     #    it up to the caller to use repo.wjoin() to get an absolute path.
     # 2) Join with '/' because that's what dirstate always uses, even on
     #    Windows. Change existing separator to '/' first in case we are
     #    passed filenames from an external source (like the command line).
     return shortname + '/' + util.pconvert(filename)
 
 def isstandin(filename):
     '''Return true if filename is a big file standin. filename must be
     in Mercurial's internal form (slash-separated).'''
     return filename.startswith(shortname + '/')
 
 def splitstandin(filename):
     # Split on / because that's what dirstate always uses, even on Windows.
     # Change local separator to / first just in case we are passed filenames
     # from an external source (like the command line).
     bits = util.pconvert(filename).split('/', 1)
     if len(bits) == 2 and bits[0] == shortname:
         return bits[1]
     else:
         return None
 
 def updatestandin(repo, standin):
     file = repo.wjoin(splitstandin(standin))
     if os.path.exists(file):
         hash = hashfile(file)
         executable = getexecutable(file)
         writestandin(repo, standin, hash, executable)
 
 def readstandin(repo, filename, node=None):
     '''read hex hash from standin for filename at given node, or working
     directory if no node is given'''
     return repo[node][standin(filename)].data().strip()
 
 def writestandin(repo, standin, hash, executable):
     '''write hash to <repo.root>/<standin>'''
     writehash(hash, repo.wjoin(standin), executable)
 
 def copyandhash(instream, outfile):
     '''Read bytes from instream (iterable) and write them to outfile,
     computing the SHA-1 hash of the data along the way.  Close outfile
     when done and return the binary hash.'''
     hasher = util.sha1('')
     for data in instream:
         hasher.update(data)
         outfile.write(data)
 
     # Blecch: closing a file that somebody else opened is rude and
     # wrong. But it's so darn convenient and practical! After all,
     # outfile was opened just to copy and hash.
     outfile.close()
 
     return hasher.digest()
 
 def hashrepofile(repo, file):
     return hashfile(repo.wjoin(file))
 
 def hashfile(file):
     if not os.path.exists(file):
         return ''
     hasher = util.sha1('')
     fd = open(file, 'rb')
     for data in blockstream(fd):
         hasher.update(data)
     fd.close()
     return hasher.hexdigest()
 
 class limitreader(object):
     def __init__(self, f, limit):
         self.f = f
         self.limit = limit
 
     def read(self, length):
         if self.limit == 0:
             return ''
         length = length > self.limit and self.limit or length
         self.limit -= length
         return self.f.read(length)
 
     def close(self):
         pass
 
 def blockstream(infile, blocksize=128 * 1024):
     """Generator that yields blocks of data from infile and closes infile."""
     while True:
         data = infile.read(blocksize)
         if not data:
             break
         yield data
     # same blecch as copyandhash() above
     infile.close()
 
 def writehash(hash, filename, executable):
     util.makedirs(os.path.dirname(filename))
     util.writefile(filename, hash + '\n')
     os.chmod(filename, getmode(executable))
 
 def getexecutable(filename):
     mode = os.stat(filename).st_mode
     return ((mode & stat.S_IXUSR) and
             (mode & stat.S_IXGRP) and
             (mode & stat.S_IXOTH))
 
 def getmode(executable):
     if executable:
         return 0755
     else:
         return 0644
 
 def urljoin(first, second, *arg):
     def join(left, right):
         if not left.endswith('/'):
             left += '/'
         if right.startswith('/'):
             right = right[1:]
         return left + right
 
     url = join(first, second)
     for a in arg:
         url = join(url, a)
     return url
 
 def hexsha1(data):
     """hexsha1 returns the hex-encoded sha1 sum of the data in the file-like
     object data"""
     h = util.sha1()
     for chunk in util.filechunkiter(data):
         h.update(chunk)
     return h.hexdigest()
 
 def httpsendfile(ui, filename):
     return httpconnection.httpsendfile(ui, filename, 'rb')
 
 def unixpath(path):
     '''Return a version of path normalized for use with the lfdirstate.'''
     return util.pconvert(os.path.normpath(path))
 
 def islfilesrepo(repo):
     if ('largefiles' in repo.requirements and
             util.any(shortname + '/' in f[0] for f in repo.store.datafiles())):
         return True
 
     return util.any(openlfdirstate(repo.ui, repo, False))
 
 class storeprotonotcapable(Exception):
     def __init__(self, storetypes):
         self.storetypes = storetypes
 
 def getcurrentheads(repo):
     branches = repo.branchmap()
     heads = []
     for branch in branches:
         newheads = repo.branchheads(branch)
         heads = heads + newheads
     return heads
 
 def getstandinsstate(repo):
     standins = []
     matcher = getstandinmatcher(repo)
     for standin in dirstatewalk(repo.dirstate, matcher):
         lfile = splitstandin(standin)
         standins.append((lfile, readstandin(repo, lfile)))
     return standins
 
 def getlfilestoupdate(oldstandins, newstandins):
     changedstandins = set(oldstandins).symmetric_difference(set(newstandins))
     filelist = []
     for f in changedstandins:
         if f[0] not in filelist:
             filelist.append(f[0])
     return filelist

tests/test-lfconvert.t

@@ -1,297 +1,338 b''
   $ USERCACHE="$TESTTMP/cache"; export USERCACHE
   $ mkdir "${USERCACHE}"
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > largefiles =
   > share =
   > graphlog =
   > mq =
+  > convert =
   > [largefiles]
   > minsize = 0.5
   > patterns = **.other
   >     **.dat
   > usercache=${USERCACHE}
   > EOF
 
 "lfconvert" works
   $ hg init bigfile-repo
   $ cd bigfile-repo
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
   > largefiles = !
   > EOF
   $ mkdir sub
   $ dd if=/dev/zero bs=1k count=256 > large 2> /dev/null
   $ dd if=/dev/zero bs=1k count=256 > large2 2> /dev/null
   $ echo normal > normal1
   $ echo alsonormal > sub/normal2
   $ dd if=/dev/zero bs=1k count=10 > sub/maybelarge.dat 2> /dev/null
   $ hg addremove
   adding large
   adding large2
   adding normal1
   adding sub/maybelarge.dat
   adding sub/normal2
   $ hg commit -m"add large, normal1" large normal1
   $ hg commit -m"add sub/*" sub
 
 Test tag parsing
   $ cat >> .hgtags <<EOF
   > IncorrectlyFormattedTag!
   > invalidhash sometag
   > 0123456789abcdef anothertag
   > EOF
   $ hg add .hgtags
   $ hg commit -m"add large2" large2 .hgtags
 
 Test link+rename largefile codepath
   $ [ -d .hg/largefiles ] && echo fail || echo pass
   pass
   $ cd ..
   $ hg lfconvert --size 0.2 bigfile-repo largefiles-repo
   initializing destination largefiles-repo
   skipping incorrectly formatted tag IncorrectlyFormattedTag!
   skipping incorrectly formatted id invalidhash
   no mapping for id 0123456789abcdef
 #if symlink
   $ hg --cwd bigfile-repo rename large2 large3
   $ ln -sf large bigfile-repo/large3
   $ hg --cwd bigfile-repo commit -m"make large2 a symlink" large2 large3
   $ hg lfconvert --size 0.2 bigfile-repo largefiles-repo-symlink
   initializing destination largefiles-repo-symlink
   skipping incorrectly formatted tag IncorrectlyFormattedTag!
   skipping incorrectly formatted id invalidhash
   no mapping for id 0123456789abcdef
   abort: renamed/copied largefile large3 becomes symlink
   [255]
 #endif
   $ cd bigfile-repo
   $ hg strip --no-backup 2
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ cd ..
   $ rm -rf largefiles-repo largefiles-repo-symlink
 
   $ hg lfconvert --size 0.2 bigfile-repo largefiles-repo
   initializing destination largefiles-repo
 
 "lfconvert" converts content correctly
   $ cd largefiles-repo
   $ hg up
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   getting changed largefiles
   2 largefiles updated, 0 removed
   $ hg locate
   .hglf/large
   .hglf/sub/maybelarge.dat
   normal1
   sub/normal2
   $ cat normal1
   normal
   $ cat sub/normal2
   alsonormal
   $ "$TESTDIR/md5sum.py" large sub/maybelarge.dat
   ec87a838931d4d5d2e94a04644788a55  large
   1276481102f218c981e0324180bafd9f  sub/maybelarge.dat
 
 "lfconvert" adds 'largefiles' to .hg/requires.
   $ cat .hg/requires
   largefiles
   revlogv1
   fncache
   store
   dotencode
 
 "lfconvert" includes a newline at the end of the standin files.
   $ cat .hglf/large .hglf/sub/maybelarge.dat
   2e000fa7e85759c7f4c254d4d9c33ef481e459a7
   34e163be8e43c5631d8b92e9c43ab0bf0fa62b9c
   $ cd ..
 
 add some changesets to rename/remove/merge
   $ cd bigfile-repo
   $ hg mv -q sub stuff
   $ hg commit -m"rename sub/ to stuff/"
   $ hg update -q 1
   $ echo blah >> normal3
   $ echo blah >> sub/normal2
   $ echo blah >> sub/maybelarge.dat
   $ "$TESTDIR/md5sum.py" sub/maybelarge.dat
   1dd0b99ff80e19cff409702a1d3f5e15  sub/maybelarge.dat
   $ hg commit -A -m"add normal3, modify sub/*"
   adding normal3
   created new head
   $ hg rm large normal3
   $ hg commit -q -m"remove large, normal3"
   $ hg merge
   merging sub/maybelarge.dat and stuff/maybelarge.dat to stuff/maybelarge.dat
   warning: $TESTTMP/bigfile-repo/stuff/maybelarge.dat looks like a binary file. (glob)
   merging stuff/maybelarge.dat incomplete! (edit conflicts, then use 'hg resolve --mark')
   merging sub/normal2 and stuff/normal2 to stuff/normal2
   0 files updated, 1 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ hg cat -r . sub/maybelarge.dat > stuff/maybelarge.dat
   $ hg resolve -m stuff/maybelarge.dat
   $ hg commit -m"merge"
   $ hg glog --template "{rev}:{node|short}  {desc|firstline}\n"
   @    5:4884f215abda  merge
   |\
   | o  4:7285f817b77e  remove large, normal3
   | |
   | o  3:67e3892e3534  add normal3, modify sub/*
   | |
   o |  2:c96c8beb5d56  rename sub/ to stuff/
   |/
   o  1:020c65d24e11  add sub/*
   |
   o  0:117b8328f97a  add large, normal1
   
   $ cd ..
 
 lfconvert with rename, merge, and remove
   $ rm -rf largefiles-repo
   $ hg lfconvert --size 0.2 bigfile-repo largefiles-repo
   initializing destination largefiles-repo
   $ cd largefiles-repo
   $ hg glog --template "{rev}:{node|short}  {desc|firstline}\n"
   o    5:8e05f5f2b77e  merge
   |\
   | o  4:a5a02de7a8e4  remove large, normal3
   | |
   | o  3:55759520c76f  add normal3, modify sub/*
   | |
   o |  2:261ad3f3f037  rename sub/ to stuff/
   |/
   o  1:334e5237836d  add sub/*
   |
   o  0:d4892ec57ce2  add large, normal1
   
   $ hg locate -r 2
   .hglf/large
   .hglf/stuff/maybelarge.dat
   normal1
   stuff/normal2
   $ hg locate -r 3
   .hglf/large
   .hglf/sub/maybelarge.dat
   normal1
   normal3
   sub/normal2
   $ hg locate -r 4
   .hglf/sub/maybelarge.dat
   normal1
   sub/normal2
   $ hg locate -r 5
   .hglf/stuff/maybelarge.dat
   normal1
   stuff/normal2
   $ hg update
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   getting changed largefiles
   1 largefiles updated, 0 removed
   $ cat stuff/normal2
   alsonormal
   blah
   $ "$TESTDIR/md5sum.py" stuff/maybelarge.dat
   1dd0b99ff80e19cff409702a1d3f5e15  stuff/maybelarge.dat
   $ cat .hglf/stuff/maybelarge.dat
   76236b6a2c6102826c61af4297dd738fb3b1de38
   $ cd ..
 
 "lfconvert" error cases
   $ hg lfconvert http://localhost/foo foo
   abort: http://localhost/foo is not a local Mercurial repo
   [255]
   $ hg lfconvert foo ssh://localhost/foo
   abort: ssh://localhost/foo is not a local Mercurial repo
   [255]
   $ hg lfconvert nosuchrepo foo
   abort: repository nosuchrepo not found!
   [255]
   $ hg share -q -U bigfile-repo shared
   $ printf 'bogus' > shared/.hg/sharedpath
   $ hg lfconvert shared foo
   abort: .hg/sharedpath points to nonexistent directory $TESTTMP/bogus! (glob)
   [255]
   $ hg lfconvert bigfile-repo largefiles-repo
   initializing destination largefiles-repo
   abort: repository largefiles-repo already exists!
   [255]
 
 add another largefile to the new largefiles repo
   $ cd largefiles-repo
   $ dd if=/dev/zero bs=1k count=1k > anotherlarge 2> /dev/null
   $ hg add --lfsize=1 anotherlarge
   $ hg commit -m "add anotherlarge (should be a largefile)"
   $ cat .hglf/anotherlarge
   3b71f43ff30f4b15b5cd85dd9e95ebc7e84eb5a3
   $ cd ..
 
 round-trip: converting back to a normal (non-largefiles) repo with
 "lfconvert --to-normal" should give the same as ../bigfile-repo
   $ cd largefiles-repo
   $ hg lfconvert --to-normal . ../normal-repo
   initializing destination ../normal-repo
   $ cd ../normal-repo
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
   > largefiles = !
   > EOF
 
 # Hmmm: the changeset ID for rev 5 is different from the original
 # normal repo (../bigfile-repo), because the changelog filelist
 # differs between the two incarnations of rev 5: this repo includes
 # 'large' in the list, but ../bigfile-repo does not. Since rev 5
 # removes 'large' relative to the first parent in both repos, it seems
 # to me that lfconvert is doing a *better* job than
 # "hg remove" + "hg merge" + "hg commit".
 #  $ hg -R ../bigfile-repo debugdata -c 5
 #  $ hg debugdata -c 5
   $ hg glog --template "{rev}:{node|short}  {desc|firstline}\n"
   o  6:1635824e6f59  add anotherlarge (should be a largefile)
   |
   o    5:7215f8deeaaf  merge
   |\
   | o  4:7285f817b77e  remove large, normal3
   | |
   | o  3:67e3892e3534  add normal3, modify sub/*
   | |
   o |  2:c96c8beb5d56  rename sub/ to stuff/
   |/
   o  1:020c65d24e11  add sub/*
   |
   o  0:117b8328f97a  add large, normal1
   
   $ hg update
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg locate
   anotherlarge
   normal1
   stuff/maybelarge.dat
   stuff/normal2
   $ [ -d .hg/largefiles ] && echo fail || echo pass
   pass
 
   $ cd ..
 
+  $ hg convert largefiles-repo
+  assuming destination largefiles-repo-hg
+  initializing destination largefiles-repo-hg repository
+  scanning source...
+  sorting...
+  converting...
+  6 add large, normal1
+  5 add sub/*
+  4 rename sub/ to stuff/
+  3 add normal3, modify sub/*
+  2 remove large, normal3
+  1 merge
+  0 add anotherlarge (should be a largefile)
+
+  $ hg -R largefiles-repo-hg glog --template "{rev}:{node|short}  {desc|firstline}\n"
+  o  6:17126745edfd  add anotherlarge (should be a largefile)
+  |
+  o    5:9cc5aa7204f0  merge
+  |\
+  | o  4:a5a02de7a8e4  remove large, normal3
+  | |
+  | o  3:55759520c76f  add normal3, modify sub/*
+  | |
+  o |  2:261ad3f3f037  rename sub/ to stuff/
+  |/
+  o  1:334e5237836d  add sub/*
+  |
+  o  0:d4892ec57ce2  add large, normal1
+  
+  $ hg -R largefiles-repo-hg verify --large --lfa
+  checking changesets
+  checking manifests
+  crosschecking files in changesets and manifests
+  checking files
+  8 files, 7 changesets, 12 total revisions
+  searching 7 changesets for largefiles
+  verified existence of 6 revisions of 4 largefiles
+  $ hg -R largefiles-repo-hg showconfig paths
+
+
 Avoid a traceback if a largefile isn't available (issue3519)
 
 Ensure the largefile can be cached in the source if necessary
   $ hg clone -U largefiles-repo issue3519
   $ rm "${USERCACHE}"/*
   $ hg lfconvert --to-normal issue3519 normalized3519
   initializing destination normalized3519
 
 Ensure the abort message is useful if a largefile is entirely unavailable
   $ rm -rf normalized3519
   $ rm "${USERCACHE}"/*
   $ rm issue3519/.hg/largefiles/*
   $ rm largefiles-repo/.hg/largefiles/*
   $ hg lfconvert --to-normal issue3519 normalized3519
   initializing destination normalized3519
   large: can't get file locally
   (no default or default-push path set in hgrc)
   abort: missing largefile 'large' from revision d4892ec57ce212905215fad1d9018f56b99202ad
   [255]