changeset 23276:4be754832829

largefiles: move "copyalltostore" invocation into "markcommitted"

Before this patch, while "hg convert", largefiles avoids copying
largefiles in the working directory into the store area by combination
of setting "repo._isconverting" in "mercurialsink{before|after}" and
checking it in "copytostoreabsolute".

This avoiding is needed while "hg convert", because converting doesn't
update largefiles in the working directory.

But this implementation is not efficient, because:

  - invocation in "markcommitted" can easily ensure updating
    largefiles in the working directory

    "markcommitted" is invoked only when new revision is committed via
    "commit" of "localrepository" (= with files in the working
    directory). On the other hand, "commitctx" may be invoked directly
    for in-memory committing.

  - committing without updating the working directory (e.g. "import
    --bypass") also needs this kind of avoiding

For efficiency of this kind of avoiding, this patch does:

  - move "copyalltostore" invocation into "markcommitted"
  - remove meaningless procedures below:
    - hooking "mercurialsink{before|after}" to (un)set "repo._isconverting"
    - checking "repo._isconverting" in "copytostoreabsolute"

This patch invokes "copyalltostore" also in "_commitcontext", because
"_commitcontext" expects that largefiles in the working directory are
copied into store area after "commitctx". In this case, the working
directory is used as a kind of temporary area to write largefiles out,
even though converted revisions are committed via "commitctx" (without
updating normal files).

--- a/hgext/largefiles/lfcommands.py	Sat Nov 08 00:48:41 2014 +0900
+++ b/hgext/largefiles/lfcommands.py	Sat Nov 08 00:48:41 2014 +0900
@@ -268,6 +268,7 @@
     mctx = context.memctx(rdst, parents, ctx.description(), dstfiles,
                           getfilectx, ctx.user(), ctx.date(), ctx.extra())
     ret = rdst.commitctx(mctx)
+    lfutil.copyalltostore(rdst, ret)
     rdst.setparents(ret)
     revmap[ctx.node()] = rdst.changelog.tip()
 

--- a/hgext/largefiles/lfutil.py	Sat Nov 08 00:48:41 2014 +0900
+++ b/hgext/largefiles/lfutil.py	Sat Nov 08 00:48:41 2014 +0900
@@ -204,7 +204,7 @@
 def copytostoreabsolute(repo, file, hash):
     if inusercache(repo.ui, hash):
         link(usercachepath(repo.ui, hash), storepath(repo, hash))
-    elif not getattr(repo, "_isconverting", False):
+    else:
         util.makedirs(os.path.dirname(storepath(repo, hash)))
         dst = util.atomictempfile(storepath(repo, hash),
                                   createmode=repo.store.createmode)
@@ -408,6 +408,9 @@
             synclfdirstate(repo, lfdirstate, lfile, False)
     lfdirstate.write()
 
+    # As part of committing, copy all of the largefiles into the cache.
+    copyalltostore(repo, node)
+
 def getlfilestoupdate(oldstandins, newstandins):
     changedstandins = set(oldstandins).symmetric_difference(set(newstandins))
     filelist = []

--- a/hgext/largefiles/overrides.py	Sat Nov 08 00:48:41 2014 +0900
+++ b/hgext/largefiles/overrides.py	Sat Nov 08 00:48:41 2014 +0900
@@ -1226,14 +1226,6 @@
         err = 0
     return err
 
-def mercurialsinkbefore(orig, sink):
-    sink.repo._isconverting = True
-    orig(sink)
-
-def mercurialsinkafter(orig, sink):
-    sink.repo._isconverting = False
-    orig(sink)
-
 def mergeupdate(orig, repo, node, branchmerge, force, partial,
                 *args, **kwargs):
     wlock = repo.wlock()

--- a/hgext/largefiles/reposetup.py	Sat Nov 08 00:48:41 2014 +0900
+++ b/hgext/largefiles/reposetup.py	Sat Nov 08 00:48:41 2014 +0900
@@ -241,11 +241,8 @@
             self.lfstatus = True
             return scmutil.status(*result)
 
-        # As part of committing, copy all of the largefiles into the
-        # cache.
         def commitctx(self, ctx, *args, **kwargs):
             node = super(lfilesrepo, self).commitctx(ctx, *args, **kwargs)
-            lfutil.copyalltostore(self, node)
             class lfilesctx(ctx.__class__):
                 def markcommitted(self, node):
                     orig = super(lfilesctx, self).markcommitted

--- a/hgext/largefiles/uisetup.py	Sat Nov 08 00:48:41 2014 +0900
+++ b/hgext/largefiles/uisetup.py	Sat Nov 08 00:48:41 2014 +0900
@@ -174,10 +174,3 @@
         if name == 'transplant':
             extensions.wrapcommand(getattr(module, 'cmdtable'), 'transplant',
                 overrides.overridetransplant)
-        if name == 'convert':
-            convcmd = getattr(module, 'convcmd')
-            hgsink = getattr(convcmd, 'mercurial_sink')
-            extensions.wrapfunction(hgsink, 'before',
-                                    overrides.mercurialsinkbefore)
-            extensions.wrapfunction(hgsink, 'after',
-                                    overrides.mercurialsinkafter)

--- a/tests/test-largefiles-update.t	Sat Nov 08 00:48:41 2014 +0900
+++ b/tests/test-largefiles-update.t	Sat Nov 08 00:48:41 2014 +0900
@@ -611,3 +611,16 @@
 #endif
 
   $ cd ..
+
+Test that "hg convert" avoids copying largefiles from the working
+directory into store, because "hg convert" doesn't update largefiles
+in the working directory (removing files under ".cache/largefiles"
+forces "hg convert" to copy corresponding largefiles)
+
+  $ cat >> $HGRCPATH <<EOF
+  > [extensions]
+  > convert =
+  > EOF
+
+  $ rm $TESTTMP/.cache/largefiles/6a4f36d4075fbe0f30ec1d26ca44e63c05903671
+  $ hg convert -q repo repo.converted