strip: compress bundle2 backup using BZ

Storing uncompressed bundle on disk would be a regression. Strip backup using
bundle2 are now compressed when requested.

mercurial/repair.py

@@ -1,296 +1,300 b''
 # repair.py - functions for repository repair for mercurial
 #
 # Copyright 2005, 2006 Chris Mason <[e-mail]>
 # Copyright 2007 Matt Mackall
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import errno
 
 from .i18n import _
 from .node import short
 from . import (
     bundle2,
     changegroup,
     exchange,
     util,
 )
 
 def _bundle(repo, bases, heads, node, suffix, compress=True):
     """create a bundle with the specified revisions as a backup"""
     cgversion = '01'
     if 'generaldelta' in repo.requirements:
         cgversion = '02'
 
     cg = changegroup.changegroupsubset(repo, bases, heads, 'strip',
                                        version=cgversion)
     backupdir = "strip-backup"
     vfs = repo.vfs
     if not vfs.isdir(backupdir):
         vfs.mkdir(backupdir)
 
     # Include a hash of all the nodes in the filename for uniqueness
     allcommits = repo.set('%ln::%ln', bases, heads)
     allhashes = sorted(c.hex() for c in allcommits)
     totalhash = util.sha1(''.join(allhashes)).hexdigest()
     name = "%s/%s-%s-%s.hg" % (backupdir, short(node), totalhash[:8], suffix)
 
+    comp = None
     if cgversion != '01':
         bundletype = "HG20"
+        if compress:
+            comp = 'BZ'
     elif compress:
         bundletype = "HG10BZ"
     else:
         bundletype = "HG10UN"
-    return changegroup.writebundle(repo.ui, cg, name, bundletype, vfs)
+    return changegroup.writebundle(repo.ui, cg, name, bundletype, vfs,
+                                   compression=comp)
 
 def _collectfiles(repo, striprev):
     """find out the filelogs affected by the strip"""
     files = set()
 
     for x in xrange(striprev, len(repo)):
         files.update(repo[x].files())
 
     return sorted(files)
 
 def _collectbrokencsets(repo, files, striprev):
     """return the changesets which will be broken by the truncation"""
     s = set()
     def collectone(revlog):
         _, brokenset = revlog.getstrippoint(striprev)
         s.update([revlog.linkrev(r) for r in brokenset])
 
     collectone(repo.manifest)
     for fname in files:
         collectone(repo.file(fname))
 
     return s
 
 def strip(ui, repo, nodelist, backup=True, topic='backup'):
 
     # Simple way to maintain backwards compatibility for this
     # argument.
     if backup in ['none', 'strip']:
         backup = False
 
     repo = repo.unfiltered()
     repo.destroying()
 
     cl = repo.changelog
     # TODO handle undo of merge sets
     if isinstance(nodelist, str):
         nodelist = [nodelist]
     striplist = [cl.rev(node) for node in nodelist]
     striprev = min(striplist)
 
     # Some revisions with rev > striprev may not be descendants of striprev.
     # We have to find these revisions and put them in a bundle, so that
     # we can restore them after the truncations.
     # To create the bundle we use repo.changegroupsubset which requires
     # the list of heads and bases of the set of interesting revisions.
     # (head = revision in the set that has no descendant in the set;
     #  base = revision in the set that has no ancestor in the set)
     tostrip = set(striplist)
     for rev in striplist:
         for desc in cl.descendants([rev]):
             tostrip.add(desc)
 
     files = _collectfiles(repo, striprev)
     saverevs = _collectbrokencsets(repo, files, striprev)
 
     # compute heads
     saveheads = set(saverevs)
     for r in xrange(striprev + 1, len(cl)):
         if r not in tostrip:
             saverevs.add(r)
             saveheads.difference_update(cl.parentrevs(r))
             saveheads.add(r)
     saveheads = [cl.node(r) for r in saveheads]
 
     # compute base nodes
     if saverevs:
         descendants = set(cl.descendants(saverevs))
         saverevs.difference_update(descendants)
     savebases = [cl.node(r) for r in saverevs]
     stripbases = [cl.node(r) for r in tostrip]
 
     # For a set s, max(parents(s) - s) is the same as max(heads(::s - s)), but
     # is much faster
     newbmtarget = repo.revs('max(parents(%ld) - (%ld))', tostrip, tostrip)
     if newbmtarget:
         newbmtarget = repo[newbmtarget.first()].node()
     else:
         newbmtarget = '.'
 
     bm = repo._bookmarks
     updatebm = []
     for m in bm:
         rev = repo[bm[m]].rev()
         if rev in tostrip:
             updatebm.append(m)
 
     # create a changegroup for all the branches we need to keep
     backupfile = None
     vfs = repo.vfs
     node = nodelist[-1]
     if backup:
         backupfile = _bundle(repo, stripbases, cl.heads(), node, topic)
         repo.ui.status(_("saved backup bundle to %s\n") %
                        vfs.join(backupfile))
         repo.ui.log("backupbundle", "saved backup bundle to %s\n",
                     vfs.join(backupfile))
     if saveheads or savebases:
         # do not compress partial bundle if we remove it from disk later
         chgrpfile = _bundle(repo, savebases, saveheads, node, 'temp',
                             compress=False)
 
     mfst = repo.manifest
 
     curtr = repo.currenttransaction()
     if curtr is not None:
         del curtr  # avoid carrying reference to transaction for nothing
         msg = _('programming error: cannot strip from inside a transaction')
         raise util.Abort(msg, hint=_('contact your extension maintainer'))
 
     tr = repo.transaction("strip")
     offset = len(tr.entries)
 
     try:
         tr.startgroup()
         cl.strip(striprev, tr)
         mfst.strip(striprev, tr)
         for fn in files:
             repo.file(fn).strip(striprev, tr)
         tr.endgroup()
 
         try:
             for i in xrange(offset, len(tr.entries)):
                 file, troffset, ignore = tr.entries[i]
                 repo.svfs(file, 'a').truncate(troffset)
                 if troffset == 0:
                     repo.store.markremoved(file)
             tr.close()
         finally:
             tr.release()
 
         if saveheads or savebases:
             ui.note(_("adding branch\n"))
             f = vfs.open(chgrpfile, "rb")
             gen = exchange.readbundle(ui, f, chgrpfile, vfs)
             if not repo.ui.verbose:
                 # silence internal shuffling chatter
                 repo.ui.pushbuffer()
             if isinstance(gen, bundle2.unbundle20):
                 tr = repo.transaction('strip')
                 tr.hookargs = {'source': 'strip',
                                'url': 'bundle:' + vfs.join(chgrpfile)}
                 try:
                     bundle2.processbundle(repo, gen, lambda: tr)
                     tr.close()
                 finally:
                     tr.release()
             else:
                 changegroup.addchangegroup(repo, gen, 'strip',
                                            'bundle:' + vfs.join(chgrpfile),
                                            True)
             if not repo.ui.verbose:
                 repo.ui.popbuffer()
             f.close()
 
         # remove undo files
         for undovfs, undofile in repo.undofiles():
             try:
                 undovfs.unlink(undofile)
             except OSError as e:
                 if e.errno != errno.ENOENT:
                     ui.warn(_('error removing %s: %s\n') %
                             (undovfs.join(undofile), str(e)))
 
         for m in updatebm:
             bm[m] = repo[newbmtarget].node()
         bm.write()
     except: # re-raises
         if backupfile:
             ui.warn(_("strip failed, full bundle stored in '%s'\n")
                     % vfs.join(backupfile))
         elif saveheads:
             ui.warn(_("strip failed, partial bundle stored in '%s'\n")
                     % vfs.join(chgrpfile))
         raise
     else:
         if saveheads or savebases:
             # Remove partial backup only if there were no exceptions
             vfs.unlink(chgrpfile)
 
     repo.destroyed()
 
 def rebuildfncache(ui, repo):
     """Rebuilds the fncache file from repo history.
 
     Missing entries will be added. Extra entries will be removed.
     """
     repo = repo.unfiltered()
 
     if 'fncache' not in repo.requirements:
         ui.warn(_('(not rebuilding fncache because repository does not '
                   'support fncache)\n'))
         return
 
     lock = repo.lock()
     try:
         fnc = repo.store.fncache
         # Trigger load of fncache.
         if 'irrelevant' in fnc:
             pass
 
         oldentries = set(fnc.entries)
         newentries = set()
         seenfiles = set()
 
         repolen = len(repo)
         for rev in repo:
             ui.progress(_('changeset'), rev, total=repolen)
 
             ctx = repo[rev]
             for f in ctx.files():
                 # This is to minimize I/O.
                 if f in seenfiles:
                     continue
                 seenfiles.add(f)
 
                 i = 'data/%s.i' % f
                 d = 'data/%s.d' % f
 
                 if repo.store._exists(i):
                     newentries.add(i)
                 if repo.store._exists(d):
                     newentries.add(d)
 
         ui.progress(_('changeset'), None)
 
         addcount = len(newentries - oldentries)
         removecount = len(oldentries - newentries)
         for p in sorted(oldentries - newentries):
             ui.write(_('removing %s\n') % p)
         for p in sorted(newentries - oldentries):
             ui.write(_('adding %s\n') % p)
 
         if addcount or removecount:
             ui.write(_('%d items added, %d removed from fncache\n') %
                      (addcount, removecount))
             fnc.entries = newentries
             fnc._dirty = True
 
             tr = repo.transaction('fncache')
             try:
                 fnc.write(tr)
                 tr.close()
             finally:
                 tr.release()
         else:
             ui.write(_('fncache already up to date\n'))
     finally:
         lock.release()
 

tests/test-generaldelta.t

@@ -1,114 +1,114 b''
 Check whether size of generaldelta revlog is not bigger than its
 regular equivalent. Test would fail if generaldelta was naive
 implementation of parentdelta: third manifest revision would be fully
 inserted due to big distance from its paren revision (zero).
 
   $ hg init repo
   $ cd repo
   $ echo foo > foo
   $ echo bar > bar
   $ hg commit -q -Am boo
   $ hg clone --pull . ../gdrepo -q --config format.generaldelta=yes
   $ for r in 1 2 3; do
   >   echo $r > foo
   >   hg commit -q -m $r
   >   hg up -q -r 0
   >   hg pull . -q -r $r -R ../gdrepo
   > done
 
   $ cd ..
   >>> import os
   >>> regsize = os.stat("repo/.hg/store/00manifest.i").st_size
   >>> gdsize = os.stat("gdrepo/.hg/store/00manifest.i").st_size
   >>> if regsize < gdsize:
   ...     print 'generaldata increased size of manifest'
 
 Verify rev reordering doesnt create invalid bundles (issue4462)
 This requires a commit tree that when pulled will reorder manifest revs such
 that the second manifest to create a file rev will be ordered before the first
 manifest to create that file rev. We also need to do a partial pull to ensure
 reordering happens. At the end we verify the linkrev points at the earliest
 commit.
 
   $ hg init server --config format.generaldelta=True
   $ cd server
   $ touch a
   $ hg commit -Aqm a
   $ echo x > x
   $ echo y > y
   $ hg commit -Aqm xy
   $ hg up -q '.^'
   $ echo x > x
   $ echo z > z
   $ hg commit -Aqm xz
   $ hg up -q 1
   $ echo b > b
   $ hg commit -Aqm b
   $ hg merge -q 2
   $ hg commit -Aqm merge
   $ echo c > c
   $ hg commit -Aqm c
   $ hg log -G -T '{rev} {shortest(node)} {desc}'
   @  5 ebb8 c
   |
   o    4 baf7 merge
   |\
   | o  3 a129 b
   | |
   o |  2 958c xz
   | |
   | o  1 f00c xy
   |/
   o  0 3903 a
   
   $ cd ..
   $ hg init client
   $ cd client
   $ hg pull -q ../server -r 4
   $ hg debugindex x
      rev    offset  length   base linkrev nodeid       p1           p2
        0         0       3      0       1 1406e7411862 000000000000 000000000000
 
   $ cd ..
 
 Test format.aggressivemergedeltas
 
   $ hg init --config format.generaldelta=1 aggressive
   $ cd aggressive
   $ touch a b c d e
   $ hg commit -Aqm side1
   $ hg up -q null
   $ touch x y
   $ hg commit -Aqm side2
 
 - Verify non-aggressive merge uses p1 (commit 1) as delta parent
   $ hg merge -q 0
   $ hg commit -q -m merge
   $ hg debugindex -m
      rev    offset  length  delta linkrev nodeid       p1           p2
        0         0      59     -1       0 8dde941edb6e 000000000000 000000000000
        1        59      59     -1       1 315c023f341d 000000000000 000000000000
        2       118      65      1       2 2ab389a983eb 315c023f341d 8dde941edb6e
 
   $ hg strip -q -r . --config extensions.strip=
 
 - Verify aggressive merge uses p2 (commit 0) as delta parent
   $ hg up -q -C 1
   $ hg merge -q 0
   $ hg commit -q -m merge --config format.aggressivemergedeltas=True
   $ hg debugindex -m
      rev    offset  length  delta linkrev nodeid       p1           p2
        0         0      59     -1       0 8dde941edb6e 000000000000 000000000000
        1        59      59     -1       1 315c023f341d 000000000000 000000000000
        2       118      62      0       2 2ab389a983eb 315c023f341d 8dde941edb6e
 
 Test that strip bundle use bundle2
   $ hg --config extensions.strip= strip .
   0 files updated, 0 files merged, 5 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/aggressive/.hg/strip-backup/1c5d4dc9a8b8-6c68e60c-backup.hg (glob)
   $ hg debugbundle .hg/strip-backup/*
-  Stream params: {}
+  Stream params: {'Compression': 'BZ'}
   changegroup -- "{'version': '02'}"
       1c5d4dc9a8b8d6e1750966d343e94db665e7a1e9
 
   $ cd ..