upgrade: extract code in its own module

Given about 2/3 or 'mercurial.repair' is now about repository upgrade, I think
it is fair to move it into its own module.

An expected benefit is the ability to drop the 'upgrade' prefix of many
functions. This will be done in coming changesets.

mercurial/debugcommands.py

@@ -1,2115 +1,2116
 # debugcommands.py - command processing for debug* commands
 #
 # Copyright 2005-2016 Matt Mackall <[e-mail]>
 #
 # 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 difflib
 import errno
 import operator
 import os
 import random
 import socket
 import string
 import sys
 import tempfile
 import time
 
 from .i18n import _
 from .node import (
     bin,
     hex,
     nullhex,
     nullid,
     nullrev,
     short,
 )
 from . import (
     bundle2,
     changegroup,
     cmdutil,
     color,
     commands,
     context,
     dagparser,
     dagutil,
     encoding,
     error,
     exchange,
     extensions,
     fileset,
     formatter,
     hg,
     localrepo,
     lock as lockmod,
     merge as mergemod,
     obsolete,
     policy,
     pvec,
     pycompat,
     repair,
     revlog,
     revset,
     revsetlang,
     scmutil,
     setdiscovery,
     simplemerge,
     smartset,
     sslutil,
     streamclone,
     templater,
     treediscovery,
+    upgrade,
     util,
     vfs as vfsmod,
 )
 
 release = lockmod.release
 
 # We reuse the command table from commands because it is easier than
 # teaching dispatch about multiple tables.
 command = cmdutil.command(commands.table)
 
 @command('debugancestor', [], _('[INDEX] REV1 REV2'), optionalrepo=True)
 def debugancestor(ui, repo, *args):
     """find the ancestor revision of two revisions in a given index"""
     if len(args) == 3:
         index, rev1, rev2 = args
         r = revlog.revlog(vfsmod.vfs(pycompat.getcwd(), audit=False), index)
         lookup = r.lookup
     elif len(args) == 2:
         if not repo:
             raise error.Abort(_('there is no Mercurial repository here '
                                 '(.hg not found)'))
         rev1, rev2 = args
         r = repo.changelog
         lookup = repo.lookup
     else:
         raise error.Abort(_('either two or three arguments required'))
     a = r.ancestor(lookup(rev1), lookup(rev2))
     ui.write('%d:%s\n' % (r.rev(a), hex(a)))
 
 @command('debugapplystreamclonebundle', [], 'FILE')
 def debugapplystreamclonebundle(ui, repo, fname):
     """apply a stream clone bundle file"""
     f = hg.openpath(ui, fname)
     gen = exchange.readbundle(ui, f, fname)
     gen.apply(repo)
 
 @command('debugbuilddag',
     [('m', 'mergeable-file', None, _('add single file mergeable changes')),
     ('o', 'overwritten-file', None, _('add single file all revs overwrite')),
     ('n', 'new-file', None, _('add new file at each rev'))],
     _('[OPTION]... [TEXT]'))
 def debugbuilddag(ui, repo, text=None,
                   mergeable_file=False,
                   overwritten_file=False,
                   new_file=False):
     """builds a repo with a given DAG from scratch in the current empty repo
 
     The description of the DAG is read from stdin if not given on the
     command line.
 
     Elements:
 
      - "+n" is a linear run of n nodes based on the current default parent
      - "." is a single node based on the current default parent
      - "$" resets the default parent to null (implied at the start);
            otherwise the default parent is always the last node created
      - "<p" sets the default parent to the backref p
      - "*p" is a fork at parent p, which is a backref
      - "*p1/p2" is a merge of parents p1 and p2, which are backrefs
      - "/p2" is a merge of the preceding node and p2
      - ":tag" defines a local tag for the preceding node
      - "@branch" sets the named branch for subsequent nodes
      - "#...\\n" is a comment up to the end of the line
 
     Whitespace between the above elements is ignored.
 
     A backref is either
 
      - a number n, which references the node curr-n, where curr is the current
        node, or
      - the name of a local tag you placed earlier using ":tag", or
      - empty to denote the default parent.
 
     All string valued-elements are either strictly alphanumeric, or must
     be enclosed in double quotes ("..."), with "\\" as escape character.
     """
 
     if text is None:
         ui.status(_("reading DAG from stdin\n"))
         text = ui.fin.read()
 
     cl = repo.changelog
     if len(cl) > 0:
         raise error.Abort(_('repository is not empty'))
 
     # determine number of revs in DAG
     total = 0
     for type, data in dagparser.parsedag(text):
         if type == 'n':
             total += 1
 
     if mergeable_file:
         linesperrev = 2
         # make a file with k lines per rev
         initialmergedlines = [str(i) for i in xrange(0, total * linesperrev)]
         initialmergedlines.append("")
 
     tags = []
 
     wlock = lock = tr = None
     try:
         wlock = repo.wlock()
         lock = repo.lock()
         tr = repo.transaction("builddag")
 
         at = -1
         atbranch = 'default'
         nodeids = []
         id = 0
         ui.progress(_('building'), id, unit=_('revisions'), total=total)
         for type, data in dagparser.parsedag(text):
             if type == 'n':
                 ui.note(('node %s\n' % str(data)))
                 id, ps = data
 
                 files = []
                 fctxs = {}
 
                 p2 = None
                 if mergeable_file:
                     fn = "mf"
                     p1 = repo[ps[0]]
                     if len(ps) > 1:
                         p2 = repo[ps[1]]
                         pa = p1.ancestor(p2)
                         base, local, other = [x[fn].data() for x in (pa, p1,
                                                                      p2)]
                         m3 = simplemerge.Merge3Text(base, local, other)
                         ml = [l.strip() for l in m3.merge_lines()]
                         ml.append("")
                     elif at > 0:
                         ml = p1[fn].data().split("\n")
                     else:
                         ml = initialmergedlines
                     ml[id * linesperrev] += " r%i" % id
                     mergedtext = "\n".join(ml)
                     files.append(fn)
                     fctxs[fn] = context.memfilectx(repo, fn, mergedtext)
 
                 if overwritten_file:
                     fn = "of"
                     files.append(fn)
                     fctxs[fn] = context.memfilectx(repo, fn, "r%i\n" % id)
 
                 if new_file:
                     fn = "nf%i" % id
                     files.append(fn)
                     fctxs[fn] = context.memfilectx(repo, fn, "r%i\n" % id)
                     if len(ps) > 1:
                         if not p2:
                             p2 = repo[ps[1]]
                         for fn in p2:
                             if fn.startswith("nf"):
                                 files.append(fn)
                                 fctxs[fn] = p2[fn]
 
                 def fctxfn(repo, cx, path):
                     return fctxs.get(path)
 
                 if len(ps) == 0 or ps[0] < 0:
                     pars = [None, None]
                 elif len(ps) == 1:
                     pars = [nodeids[ps[0]], None]
                 else:
                     pars = [nodeids[p] for p in ps]
                 cx = context.memctx(repo, pars, "r%i" % id, files, fctxfn,
                                     date=(id, 0),
                                     user="debugbuilddag",
                                     extra={'branch': atbranch})
                 nodeid = repo.commitctx(cx)
                 nodeids.append(nodeid)
                 at = id
             elif type == 'l':
                 id, name = data
                 ui.note(('tag %s\n' % name))
                 tags.append("%s %s\n" % (hex(repo.changelog.node(id)), name))
             elif type == 'a':
                 ui.note(('branch %s\n' % data))
                 atbranch = data
             ui.progress(_('building'), id, unit=_('revisions'), total=total)
         tr.close()
 
         if tags:
             repo.vfs.write("localtags", "".join(tags))
     finally:
         ui.progress(_('building'), None)
         release(tr, lock, wlock)
 
 def _debugchangegroup(ui, gen, all=None, indent=0, **opts):
     indent_string = ' ' * indent
     if all:
         ui.write(("%sformat: id, p1, p2, cset, delta base, len(delta)\n")
                  % indent_string)
 
         def showchunks(named):
             ui.write("\n%s%s\n" % (indent_string, named))
             chain = None
             for chunkdata in iter(lambda: gen.deltachunk(chain), {}):
                 node = chunkdata['node']
                 p1 = chunkdata['p1']
                 p2 = chunkdata['p2']
                 cs = chunkdata['cs']
                 deltabase = chunkdata['deltabase']
                 delta = chunkdata['delta']
                 ui.write("%s%s %s %s %s %s %s\n" %
                          (indent_string, hex(node), hex(p1), hex(p2),
                           hex(cs), hex(deltabase), len(delta)))
                 chain = node
 
         chunkdata = gen.changelogheader()
         showchunks("changelog")
         chunkdata = gen.manifestheader()
         showchunks("manifest")
         for chunkdata in iter(gen.filelogheader, {}):
             fname = chunkdata['filename']
             showchunks(fname)
     else:
         if isinstance(gen, bundle2.unbundle20):
             raise error.Abort(_('use debugbundle2 for this file'))
         chunkdata = gen.changelogheader()
         chain = None
         for chunkdata in iter(lambda: gen.deltachunk(chain), {}):
             node = chunkdata['node']
             ui.write("%s%s\n" % (indent_string, hex(node)))
             chain = node
 
 def _debugbundle2(ui, gen, all=None, **opts):
     """lists the contents of a bundle2"""
     if not isinstance(gen, bundle2.unbundle20):
         raise error.Abort(_('not a bundle2 file'))
     ui.write(('Stream params: %s\n' % repr(gen.params)))
     for part in gen.iterparts():
         ui.write('%s -- %r\n' % (part.type, repr(part.params)))
         if part.type == 'changegroup':
             version = part.params.get('version', '01')
             cg = changegroup.getunbundler(version, part, 'UN')
             _debugchangegroup(ui, cg, all=all, indent=4, **opts)
 
 @command('debugbundle',
         [('a', 'all', None, _('show all details')),
          ('', 'spec', None, _('print the bundlespec of the bundle'))],
         _('FILE'),
         norepo=True)
 def debugbundle(ui, bundlepath, all=None, spec=None, **opts):
     """lists the contents of a bundle"""
     with hg.openpath(ui, bundlepath) as f:
         if spec:
             spec = exchange.getbundlespec(ui, f)
             ui.write('%s\n' % spec)
             return
 
         gen = exchange.readbundle(ui, f, bundlepath)
         if isinstance(gen, bundle2.unbundle20):
             return _debugbundle2(ui, gen, all=all, **opts)
         _debugchangegroup(ui, gen, all=all, **opts)
 
 @command('debugcheckstate', [], '')
 def debugcheckstate(ui, repo):
     """validate the correctness of the current dirstate"""
     parent1, parent2 = repo.dirstate.parents()
     m1 = repo[parent1].manifest()
     m2 = repo[parent2].manifest()
     errors = 0
     for f in repo.dirstate:
         state = repo.dirstate[f]
         if state in "nr" and f not in m1:
             ui.warn(_("%s in state %s, but not in manifest1\n") % (f, state))
             errors += 1
         if state in "a" and f in m1:
             ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state))
             errors += 1
         if state in "m" and f not in m1 and f not in m2:
             ui.warn(_("%s in state %s, but not in either manifest\n") %
                     (f, state))
             errors += 1
     for f in m1:
         state = repo.dirstate[f]
         if state not in "nrm":
             ui.warn(_("%s in manifest1, but listed as state %s") % (f, state))
             errors += 1
     if errors:
         error = _(".hg/dirstate inconsistent with current parent's manifest")
         raise error.Abort(error)
 
 @command('debugcolor',
         [('', 'style', None, _('show all configured styles'))],
         'hg debugcolor')
 def debugcolor(ui, repo, **opts):
     """show available color, effects or style"""
     ui.write(('color mode: %s\n') % ui._colormode)
     if opts.get('style'):
         return _debugdisplaystyle(ui)
     else:
         return _debugdisplaycolor(ui)
 
 def _debugdisplaycolor(ui):
     ui = ui.copy()
     ui._styles.clear()
     for effect in color._activeeffects(ui).keys():
         ui._styles[effect] = effect
     if ui._terminfoparams:
         for k, v in ui.configitems('color'):
             if k.startswith('color.'):
                 ui._styles[k] = k[6:]
             elif k.startswith('terminfo.'):
                 ui._styles[k] = k[9:]
     ui.write(_('available colors:\n'))
     # sort label with a '_' after the other to group '_background' entry.
     items = sorted(ui._styles.items(),
                    key=lambda i: ('_' in i[0], i[0], i[1]))
     for colorname, label in items:
         ui.write(('%s\n') % colorname, label=label)
 
 def _debugdisplaystyle(ui):
     ui.write(_('available style:\n'))
     width = max(len(s) for s in ui._styles)
     for label, effects in sorted(ui._styles.items()):
         ui.write('%s' % label, label=label)
         if effects:
             # 50
             ui.write(': ')
             ui.write(' ' * (max(0, width - len(label))))
             ui.write(', '.join(ui.label(e, e) for e in effects.split()))
         ui.write('\n')
 
 @command('debugcommands', [], _('[COMMAND]'), norepo=True)
 def debugcommands(ui, cmd='', *args):
     """list all available commands and options"""
     for cmd, vals in sorted(commands.table.iteritems()):
         cmd = cmd.split('|')[0].strip('^')
         opts = ', '.join([i[1] for i in vals[1]])
         ui.write('%s: %s\n' % (cmd, opts))
 
 @command('debugcomplete',
     [('o', 'options', None, _('show the command options'))],
     _('[-o] CMD'),
     norepo=True)
 def debugcomplete(ui, cmd='', **opts):
     """returns the completion list associated with the given command"""
 
     if opts.get('options'):
         options = []
         otables = [commands.globalopts]
         if cmd:
             aliases, entry = cmdutil.findcmd(cmd, commands.table, False)
             otables.append(entry[1])
         for t in otables:
             for o in t:
                 if "(DEPRECATED)" in o[3]:
                     continue
                 if o[0]:
                     options.append('-%s' % o[0])
                 options.append('--%s' % o[1])
         ui.write("%s\n" % "\n".join(options))
         return
 
     cmdlist, unused_allcmds = cmdutil.findpossible(cmd, commands.table)
     if ui.verbose:
         cmdlist = [' '.join(c[0]) for c in cmdlist.values()]
     ui.write("%s\n" % "\n".join(sorted(cmdlist)))
 
 @command('debugcreatestreamclonebundle', [], 'FILE')
 def debugcreatestreamclonebundle(ui, repo, fname):
     """create a stream clone bundle file
 
     Stream bundles are special bundles that are essentially archives of
     revlog files. They are commonly used for cloning very quickly.
     """
     requirements, gen = streamclone.generatebundlev1(repo)
     changegroup.writechunks(ui, gen, fname)
 
     ui.write(_('bundle requirements: %s\n') % ', '.join(sorted(requirements)))
 
 @command('debugdag',
     [('t', 'tags', None, _('use tags as labels')),
     ('b', 'branches', None, _('annotate with branch names')),
     ('', 'dots', None, _('use dots for runs')),
     ('s', 'spaces', None, _('separate elements by spaces'))],
     _('[OPTION]... [FILE [REV]...]'),
     optionalrepo=True)
 def debugdag(ui, repo, file_=None, *revs, **opts):
     """format the changelog or an index DAG as a concise textual description
 
     If you pass a revlog index, the revlog's DAG is emitted. If you list
     revision numbers, they get labeled in the output as rN.
 
     Otherwise, the changelog DAG of the current repo is emitted.
     """
     spaces = opts.get('spaces')
     dots = opts.get('dots')
     if file_:
         rlog = revlog.revlog(vfsmod.vfs(pycompat.getcwd(), audit=False),
                              file_)
         revs = set((int(r) for r in revs))
         def events():
             for r in rlog:
                 yield 'n', (r, list(p for p in rlog.parentrevs(r)
                                         if p != -1))
                 if r in revs:
                     yield 'l', (r, "r%i" % r)
     elif repo:
         cl = repo.changelog
         tags = opts.get('tags')
         branches = opts.get('branches')
         if tags:
             labels = {}
             for l, n in repo.tags().items():
                 labels.setdefault(cl.rev(n), []).append(l)
         def events():
             b = "default"
             for r in cl:
                 if branches:
                     newb = cl.read(cl.node(r))[5]['branch']
                     if newb != b:
                         yield 'a', newb
                         b = newb
                 yield 'n', (r, list(p for p in cl.parentrevs(r)
                                         if p != -1))
                 if tags:
                     ls = labels.get(r)
                     if ls:
                         for l in ls:
                             yield 'l', (r, l)
     else:
         raise error.Abort(_('need repo for changelog dag'))
 
     for line in dagparser.dagtextlines(events(),
                                        addspaces=spaces,
                                        wraplabels=True,
                                        wrapannotations=True,
                                        wrapnonlinear=dots,
                                        usedots=dots,
                                        maxlinewidth=70):
         ui.write(line)
         ui.write("\n")
 
 @command('debugdata', commands.debugrevlogopts, _('-c|-m|FILE REV'))
 def debugdata(ui, repo, file_, rev=None, **opts):
     """dump the contents of a data file revision"""
     if opts.get('changelog') or opts.get('manifest') or opts.get('dir'):
         if rev is not None:
             raise error.CommandError('debugdata', _('invalid arguments'))
         file_, rev = None, file_
     elif rev is None:
         raise error.CommandError('debugdata', _('invalid arguments'))
     r = cmdutil.openrevlog(repo, 'debugdata', file_, opts)
     try:
         ui.write(r.revision(r.lookup(rev), raw=True))
     except KeyError:
         raise error.Abort(_('invalid revision identifier %s') % rev)
 
 @command('debugdate',
     [('e', 'extended', None, _('try extended date formats'))],
     _('[-e] DATE [RANGE]'),
     norepo=True, optionalrepo=True)
 def debugdate(ui, date, range=None, **opts):
     """parse and display a date"""
     if opts["extended"]:
         d = util.parsedate(date, util.extendeddateformats)
     else:
         d = util.parsedate(date)
     ui.write(("internal: %s %s\n") % d)
     ui.write(("standard: %s\n") % util.datestr(d))
     if range:
         m = util.matchdate(range)
         ui.write(("match: %s\n") % m(d[0]))
 
 @command('debugdeltachain',
     commands.debugrevlogopts + commands.formatteropts,
     _('-c|-m|FILE'),
     optionalrepo=True)
 def debugdeltachain(ui, repo, file_=None, **opts):
     """dump information about delta chains in a revlog
 
     Output can be templatized. Available template keywords are:
 
     :``rev``:       revision number
     :``chainid``:   delta chain identifier (numbered by unique base)
     :``chainlen``:  delta chain length to this revision
     :``prevrev``:   previous revision in delta chain
     :``deltatype``: role of delta / how it was computed
     :``compsize``:  compressed size of revision
     :``uncompsize``: uncompressed size of revision
     :``chainsize``: total size of compressed revisions in chain
     :``chainratio``: total chain size divided by uncompressed revision size
                     (new delta chains typically start at ratio 2.00)
     :``lindist``:   linear distance from base revision in delta chain to end
                     of this revision
     :``extradist``: total size of revisions not part of this delta chain from
                     base of delta chain to end of this revision; a measurement
                     of how much extra data we need to read/seek across to read
                     the delta chain for this revision
     :``extraratio``: extradist divided by chainsize; another representation of
                     how much unrelated data is needed to load this delta chain
     """
     r = cmdutil.openrevlog(repo, 'debugdeltachain', file_, opts)
     index = r.index
     generaldelta = r.version & revlog.REVLOGGENERALDELTA
 
     def revinfo(rev):
         e = index[rev]
         compsize = e[1]
         uncompsize = e[2]
         chainsize = 0
 
         if generaldelta:
             if e[3] == e[5]:
                 deltatype = 'p1'
             elif e[3] == e[6]:
                 deltatype = 'p2'
             elif e[3] == rev - 1:
                 deltatype = 'prev'
             elif e[3] == rev:
                 deltatype = 'base'
             else:
                 deltatype = 'other'
         else:
             if e[3] == rev:
                 deltatype = 'base'
             else:
                 deltatype = 'prev'
 
         chain = r._deltachain(rev)[0]
         for iterrev in chain:
             e = index[iterrev]
             chainsize += e[1]
 
         return compsize, uncompsize, deltatype, chain, chainsize
 
     fm = ui.formatter('debugdeltachain', opts)
 
     fm.plain('    rev  chain# chainlen     prev   delta       '
              'size    rawsize  chainsize     ratio   lindist extradist '
              'extraratio\n')
 
     chainbases = {}
     for rev in r:
         comp, uncomp, deltatype, chain, chainsize = revinfo(rev)
         chainbase = chain[0]
         chainid = chainbases.setdefault(chainbase, len(chainbases) + 1)
         basestart = r.start(chainbase)
         revstart = r.start(rev)
         lineardist = revstart + comp - basestart
         extradist = lineardist - chainsize
         try:
             prevrev = chain[-2]
         except IndexError:
             prevrev = -1
 
         chainratio = float(chainsize) / float(uncomp)
         extraratio = float(extradist) / float(chainsize)
 
         fm.startitem()
         fm.write('rev chainid chainlen prevrev deltatype compsize '
                  'uncompsize chainsize chainratio lindist extradist '
                  'extraratio',
                  '%7d %7d %8d %8d %7s %10d %10d %10d %9.5f %9d %9d %10.5f\n',
                  rev, chainid, len(chain), prevrev, deltatype, comp,
                  uncomp, chainsize, chainratio, lineardist, extradist,
                  extraratio,
                  rev=rev, chainid=chainid, chainlen=len(chain),
                  prevrev=prevrev, deltatype=deltatype, compsize=comp,
                  uncompsize=uncomp, chainsize=chainsize,
                  chainratio=chainratio, lindist=lineardist,
                  extradist=extradist, extraratio=extraratio)
 
     fm.end()
 
 @command('debugdirstate|debugstate',
     [('', 'nodates', None, _('do not display the saved mtime')),
     ('', 'datesort', None, _('sort by saved mtime'))],
     _('[OPTION]...'))
 def debugstate(ui, repo, **opts):
     """show the contents of the current dirstate"""
 
     nodates = opts.get('nodates')
     datesort = opts.get('datesort')
 
     timestr = ""
     if datesort:
         keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename
     else:
         keyfunc = None # sort by filename
     for file_, ent in sorted(repo.dirstate._map.iteritems(), key=keyfunc):
         if ent[3] == -1:
             timestr = 'unset               '
         elif nodates:
             timestr = 'set                 '
         else:
             timestr = time.strftime("%Y-%m-%d %H:%M:%S ",
                                     time.localtime(ent[3]))
         if ent[1] & 0o20000:
             mode = 'lnk'
         else:
             mode = '%3o' % (ent[1] & 0o777 & ~util.umask)
         ui.write("%c %s %10d %s%s\n" % (ent[0], mode, ent[2], timestr, file_))
     for f in repo.dirstate.copies():
         ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
 
 @command('debugdiscovery',
     [('', 'old', None, _('use old-style discovery')),
     ('', 'nonheads', None,
      _('use old-style discovery with non-heads included')),
     ] + commands.remoteopts,
     _('[-l REV] [-r REV] [-b BRANCH]... [OTHER]'))
 def debugdiscovery(ui, repo, remoteurl="default", **opts):
     """runs the changeset discovery protocol in isolation"""
     remoteurl, branches = hg.parseurl(ui.expandpath(remoteurl),
                                       opts.get('branch'))
     remote = hg.peer(repo, opts, remoteurl)
     ui.status(_('comparing with %s\n') % util.hidepassword(remoteurl))
 
     # make sure tests are repeatable
     random.seed(12323)
 
     def doit(localheads, remoteheads, remote=remote):
         if opts.get('old'):
             if localheads:
                 raise error.Abort('cannot use localheads with old style '
                                  'discovery')
             if not util.safehasattr(remote, 'branches'):
                 # enable in-client legacy support
                 remote = localrepo.locallegacypeer(remote.local())
             common, _in, hds = treediscovery.findcommonincoming(repo, remote,
                                                                 force=True)
             common = set(common)
             if not opts.get('nonheads'):
                 ui.write(("unpruned common: %s\n") %
                          " ".join(sorted(short(n) for n in common)))
                 dag = dagutil.revlogdag(repo.changelog)
                 all = dag.ancestorset(dag.internalizeall(common))
                 common = dag.externalizeall(dag.headsetofconnecteds(all))
         else:
             common, any, hds = setdiscovery.findcommonheads(ui, repo, remote)
         common = set(common)
         rheads = set(hds)
         lheads = set(repo.heads())
         ui.write(("common heads: %s\n") %
                  " ".join(sorted(short(n) for n in common)))
         if lheads <= common:
             ui.write(("local is subset\n"))
         elif rheads <= common:
             ui.write(("remote is subset\n"))
 
     serverlogs = opts.get('serverlog')
     if serverlogs:
         for filename in serverlogs:
             with open(filename, 'r') as logfile:
                 line = logfile.readline()
                 while line:
                     parts = line.strip().split(';')
                     op = parts[1]
                     if op == 'cg':
                         pass
                     elif op == 'cgss':
                         doit(parts[2].split(' '), parts[3].split(' '))
                     elif op == 'unb':
                         doit(parts[3].split(' '), parts[2].split(' '))
                     line = logfile.readline()
     else:
         remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches,
                                                  opts.get('remote_head'))
         localrevs = opts.get('local_head')
         doit(localrevs, remoterevs)
 
 @command('debugextensions', commands.formatteropts, [], norepo=True)
 def debugextensions(ui, **opts):
     '''show information about active extensions'''
     exts = extensions.extensions(ui)
     hgver = util.version()
     fm = ui.formatter('debugextensions', opts)
     for extname, extmod in sorted(exts, key=operator.itemgetter(0)):
         isinternal = extensions.ismoduleinternal(extmod)
         extsource = pycompat.fsencode(extmod.__file__)
         if isinternal:
             exttestedwith = []  # never expose magic string to users
         else:
             exttestedwith = getattr(extmod, 'testedwith', '').split()
         extbuglink = getattr(extmod, 'buglink', None)
 
         fm.startitem()
 
         if ui.quiet or ui.verbose:
             fm.write('name', '%s\n', extname)
         else:
             fm.write('name', '%s', extname)
             if isinternal or hgver in exttestedwith:
                 fm.plain('\n')
             elif not exttestedwith:
                 fm.plain(_(' (untested!)\n'))
             else:
                 lasttestedversion = exttestedwith[-1]
                 fm.plain(' (%s!)\n' % lasttestedversion)
 
         fm.condwrite(ui.verbose and extsource, 'source',
                  _('  location: %s\n'), extsource or "")
 
         if ui.verbose:
             fm.plain(_('  bundled: %s\n') % ['no', 'yes'][isinternal])
         fm.data(bundled=isinternal)
 
         fm.condwrite(ui.verbose and exttestedwith, 'testedwith',
                      _('  tested with: %s\n'),
                      fm.formatlist(exttestedwith, name='ver'))
 
         fm.condwrite(ui.verbose and extbuglink, 'buglink',
                  _('  bug reporting: %s\n'), extbuglink or "")
 
     fm.end()
 
 @command('debugfileset',
     [('r', 'rev', '', _('apply the filespec on this revision'), _('REV'))],
     _('[-r REV] FILESPEC'))
 def debugfileset(ui, repo, expr, **opts):
     '''parse and apply a fileset specification'''
     ctx = scmutil.revsingle(repo, opts.get('rev'), None)
     if ui.verbose:
         tree = fileset.parse(expr)
         ui.note(fileset.prettyformat(tree), "\n")
 
     for f in ctx.getfileset(expr):
         ui.write("%s\n" % f)
 
 @command('debugfsinfo', [], _('[PATH]'), norepo=True)
 def debugfsinfo(ui, path="."):
     """show information detected about current filesystem"""
     ui.write(('exec: %s\n') % (util.checkexec(path) and 'yes' or 'no'))
     ui.write(('fstype: %s\n') % (util.getfstype(path) or '(unknown)'))
     ui.write(('symlink: %s\n') % (util.checklink(path) and 'yes' or 'no'))
     ui.write(('hardlink: %s\n') % (util.checknlink(path) and 'yes' or 'no'))
     casesensitive = '(unknown)'
     try:
         with tempfile.NamedTemporaryFile(prefix='.debugfsinfo', dir=path) as f:
             casesensitive = util.fscasesensitive(f.name) and 'yes' or 'no'
     except OSError:
         pass
     ui.write(('case-sensitive: %s\n') % casesensitive)
 
 @command('debuggetbundle',
     [('H', 'head', [], _('id of head node'), _('ID')),
     ('C', 'common', [], _('id of common node'), _('ID')),
     ('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE'))],
     _('REPO FILE [-H|-C ID]...'),
     norepo=True)
 def debuggetbundle(ui, repopath, bundlepath, head=None, common=None, **opts):
     """retrieves a bundle from a repo
 
     Every ID must be a full-length hex node id string. Saves the bundle to the
     given file.
     """
     repo = hg.peer(ui, opts, repopath)
     if not repo.capable('getbundle'):
         raise error.Abort("getbundle() not supported by target repository")
     args = {}
     if common:
         args['common'] = [bin(s) for s in common]
     if head:
         args['heads'] = [bin(s) for s in head]
     # TODO: get desired bundlecaps from command line.
     args['bundlecaps'] = None
     bundle = repo.getbundle('debug', **args)
 
     bundletype = opts.get('type', 'bzip2').lower()
     btypes = {'none': 'HG10UN',
               'bzip2': 'HG10BZ',
               'gzip': 'HG10GZ',
               'bundle2': 'HG20'}
     bundletype = btypes.get(bundletype)
     if bundletype not in bundle2.bundletypes:
         raise error.Abort(_('unknown bundle type specified with --type'))
     bundle2.writebundle(ui, bundle, bundlepath, bundletype)
 
 @command('debugignore', [], '[FILE]')
 def debugignore(ui, repo, *files, **opts):
     """display the combined ignore pattern and information about ignored files
 
     With no argument display the combined ignore pattern.
 
     Given space separated file names, shows if the given file is ignored and
     if so, show the ignore rule (file and line number) that matched it.
     """
     ignore = repo.dirstate._ignore
     if not files:
         # Show all the patterns
         includepat = getattr(ignore, 'includepat', None)
         if includepat is not None:
             ui.write("%s\n" % includepat)
         else:
             raise error.Abort(_("no ignore patterns found"))
     else:
         for f in files:
             nf = util.normpath(f)
             ignored = None
             ignoredata = None
             if nf != '.':
                 if ignore(nf):
                     ignored = nf
                     ignoredata = repo.dirstate._ignorefileandline(nf)
                 else:
                     for p in util.finddirs(nf):
                         if ignore(p):
                             ignored = p
                             ignoredata = repo.dirstate._ignorefileandline(p)
                             break
             if ignored:
                 if ignored == nf:
                     ui.write(_("%s is ignored\n") % f)
                 else:
                     ui.write(_("%s is ignored because of "
                                "containing folder %s\n")
                              % (f, ignored))
                 ignorefile, lineno, line = ignoredata
                 ui.write(_("(ignore rule in %s, line %d: '%s')\n")
                          % (ignorefile, lineno, line))
             else:
                 ui.write(_("%s is not ignored\n") % f)
 
 @command('debugindex', commands.debugrevlogopts +
     [('f', 'format', 0, _('revlog format'), _('FORMAT'))],
     _('[-f FORMAT] -c|-m|FILE'),
     optionalrepo=True)
 def debugindex(ui, repo, file_=None, **opts):
     """dump the contents of an index file"""
     r = cmdutil.openrevlog(repo, 'debugindex', file_, opts)
     format = opts.get('format', 0)
     if format not in (0, 1):
         raise error.Abort(_("unknown format %d") % format)
 
     generaldelta = r.version & revlog.REVLOGGENERALDELTA
     if generaldelta:
         basehdr = ' delta'
     else:
         basehdr = '  base'
 
     if ui.debugflag:
         shortfn = hex
     else:
         shortfn = short
 
     # There might not be anything in r, so have a sane default
     idlen = 12
     for i in r:
         idlen = len(shortfn(r.node(i)))
         break
 
     if format == 0:
         ui.write(("   rev    offset  length " + basehdr + " linkrev"
                  " %s %s p2\n") % ("nodeid".ljust(idlen), "p1".ljust(idlen)))
     elif format == 1:
         ui.write(("   rev flag   offset   length"
                  "     size " + basehdr + "   link     p1     p2"
                  " %s\n") % "nodeid".rjust(idlen))
 
     for i in r:
         node = r.node(i)
         if generaldelta:
             base = r.deltaparent(i)
         else:
             base = r.chainbase(i)
         if format == 0:
             try:
                 pp = r.parents(node)
             except Exception:
                 pp = [nullid, nullid]
             ui.write("% 6d % 9d % 7d % 6d % 7d %s %s %s\n" % (
                     i, r.start(i), r.length(i), base, r.linkrev(i),
                     shortfn(node), shortfn(pp[0]), shortfn(pp[1])))
         elif format == 1:
             pr = r.parentrevs(i)
             ui.write("% 6d %04x % 8d % 8d % 8d % 6d % 6d % 6d % 6d %s\n" % (
                     i, r.flags(i), r.start(i), r.length(i), r.rawsize(i),
                     base, r.linkrev(i), pr[0], pr[1], shortfn(node)))
 
 @command('debugindexdot', commands.debugrevlogopts,
     _('-c|-m|FILE'), optionalrepo=True)
 def debugindexdot(ui, repo, file_=None, **opts):
     """dump an index DAG as a graphviz dot file"""
     r = cmdutil.openrevlog(repo, 'debugindexdot', file_, opts)
     ui.write(("digraph G {\n"))
     for i in r:
         node = r.node(i)
         pp = r.parents(node)
         ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i))
         if pp[1] != nullid:
             ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i))
     ui.write("}\n")
 
 @command('debuginstall', [] + commands.formatteropts, '', norepo=True)
 def debuginstall(ui, **opts):
     '''test Mercurial installation
 
     Returns 0 on success.
     '''
 
     def writetemp(contents):
         (fd, name) = tempfile.mkstemp(prefix="hg-debuginstall-")
         f = os.fdopen(fd, pycompat.sysstr("wb"))
         f.write(contents)
         f.close()
         return name
 
     problems = 0
 
     fm = ui.formatter('debuginstall', opts)
     fm.startitem()
 
     # encoding
     fm.write('encoding', _("checking encoding (%s)...\n"), encoding.encoding)
     err = None
     try:
         encoding.fromlocal("test")
     except error.Abort as inst:
         err = inst
         problems += 1
     fm.condwrite(err, 'encodingerror', _(" %s\n"
                  " (check that your locale is properly set)\n"), err)
 
     # Python
     fm.write('pythonexe', _("checking Python executable (%s)\n"),
              pycompat.sysexecutable)
     fm.write('pythonver', _("checking Python version (%s)\n"),
              ("%d.%d.%d" % sys.version_info[:3]))
     fm.write('pythonlib', _("checking Python lib (%s)...\n"),
              os.path.dirname(pycompat.fsencode(os.__file__)))
 
     security = set(sslutil.supportedprotocols)
     if sslutil.hassni:
         security.add('sni')
 
     fm.write('pythonsecurity', _("checking Python security support (%s)\n"),
              fm.formatlist(sorted(security), name='protocol',
                            fmt='%s', sep=','))
 
     # These are warnings, not errors. So don't increment problem count. This
     # may change in the future.
     if 'tls1.2' not in security:
         fm.plain(_('  TLS 1.2 not supported by Python install; '
                    'network connections lack modern security\n'))
     if 'sni' not in security:
         fm.plain(_('  SNI not supported by Python install; may have '
                    'connectivity issues with some servers\n'))
 
     # TODO print CA cert info
 
     # hg version
     hgver = util.version()
     fm.write('hgver', _("checking Mercurial version (%s)\n"),
              hgver.split('+')[0])
     fm.write('hgverextra', _("checking Mercurial custom build (%s)\n"),
              '+'.join(hgver.split('+')[1:]))
 
     # compiled modules
     fm.write('hgmodulepolicy', _("checking module policy (%s)\n"),
              policy.policy)
     fm.write('hgmodules', _("checking installed modules (%s)...\n"),
              os.path.dirname(pycompat.fsencode(__file__)))
 
     err = None
     try:
         from . import (
             base85,
             bdiff,
             mpatch,
             osutil,
         )
         dir(bdiff), dir(mpatch), dir(base85), dir(osutil) # quiet pyflakes
     except Exception as inst:
         err = inst
         problems += 1
     fm.condwrite(err, 'extensionserror', " %s\n", err)
 
     compengines = util.compengines._engines.values()
     fm.write('compengines', _('checking registered compression engines (%s)\n'),
              fm.formatlist(sorted(e.name() for e in compengines),
                            name='compengine', fmt='%s', sep=', '))
     fm.write('compenginesavail', _('checking available compression engines '
                                    '(%s)\n'),
              fm.formatlist(sorted(e.name() for e in compengines
                                   if e.available()),
                            name='compengine', fmt='%s', sep=', '))
     wirecompengines = util.compengines.supportedwireengines(util.SERVERROLE)
     fm.write('compenginesserver', _('checking available compression engines '
                                     'for wire protocol (%s)\n'),
              fm.formatlist([e.name() for e in wirecompengines
                             if e.wireprotosupport()],
                            name='compengine', fmt='%s', sep=', '))
 
     # templates
     p = templater.templatepaths()
     fm.write('templatedirs', 'checking templates (%s)...\n', ' '.join(p))
     fm.condwrite(not p, '', _(" no template directories found\n"))
     if p:
         m = templater.templatepath("map-cmdline.default")
         if m:
             # template found, check if it is working
             err = None
             try:
                 templater.templater.frommapfile(m)
             except Exception as inst:
                 err = inst
                 p = None
             fm.condwrite(err, 'defaulttemplateerror', " %s\n", err)
         else:
             p = None
         fm.condwrite(p, 'defaulttemplate',
                      _("checking default template (%s)\n"), m)
         fm.condwrite(not m, 'defaulttemplatenotfound',
                      _(" template '%s' not found\n"), "default")
     if not p:
         problems += 1
     fm.condwrite(not p, '',
                  _(" (templates seem to have been installed incorrectly)\n"))
 
     # editor
     editor = ui.geteditor()
     editor = util.expandpath(editor)
     fm.write('editor', _("checking commit editor... (%s)\n"), editor)
     cmdpath = util.findexe(pycompat.shlexsplit(editor)[0])
     fm.condwrite(not cmdpath and editor == 'vi', 'vinotfound',
                  _(" No commit editor set and can't find %s in PATH\n"
                    " (specify a commit editor in your configuration"
                    " file)\n"), not cmdpath and editor == 'vi' and editor)
     fm.condwrite(not cmdpath and editor != 'vi', 'editornotfound',
                  _(" Can't find editor '%s' in PATH\n"
                    " (specify a commit editor in your configuration"
                    " file)\n"), not cmdpath and editor)
     if not cmdpath and editor != 'vi':
         problems += 1
 
     # check username
     username = None
     err = None
     try:
         username = ui.username()
     except error.Abort as e:
         err = e
         problems += 1
 
     fm.condwrite(username, 'username',  _("checking username (%s)\n"), username)
     fm.condwrite(err, 'usernameerror', _("checking username...\n %s\n"
         " (specify a username in your configuration file)\n"), err)
 
     fm.condwrite(not problems, '',
                  _("no problems detected\n"))
     if not problems:
         fm.data(problems=problems)
     fm.condwrite(problems, 'problems',
                  _("%d problems detected,"
                    " please check your install!\n"), problems)
     fm.end()
 
     return problems
 
 @command('debugknown', [], _('REPO ID...'), norepo=True)
 def debugknown(ui, repopath, *ids, **opts):
     """test whether node ids are known to a repo
 
     Every ID must be a full-length hex node id string. Returns a list of 0s
     and 1s indicating unknown/known.
     """
     repo = hg.peer(ui, opts, repopath)
     if not repo.capable('known'):
         raise error.Abort("known() not supported by target repository")
     flags = repo.known([bin(s) for s in ids])
     ui.write("%s\n" % ("".join([f and "1" or "0" for f in flags])))
 
 @command('debuglabelcomplete', [], _('LABEL...'))
 def debuglabelcomplete(ui, repo, *args):
     '''backwards compatibility with old bash completion scripts (DEPRECATED)'''
     debugnamecomplete(ui, repo, *args)
 
 @command('debuglocks',
          [('L', 'force-lock', None, _('free the store lock (DANGEROUS)')),
           ('W', 'force-wlock', None,
            _('free the working state lock (DANGEROUS)'))],
          _('[OPTION]...'))
 def debuglocks(ui, repo, **opts):
     """show or modify state of locks
 
     By default, this command will show which locks are held. This
     includes the user and process holding the lock, the amount of time
     the lock has been held, and the machine name where the process is
     running if it's not local.
 
     Locks protect the integrity of Mercurial's data, so should be
     treated with care. System crashes or other interruptions may cause
     locks to not be properly released, though Mercurial will usually
     detect and remove such stale locks automatically.
 
     However, detecting stale locks may not always be possible (for
     instance, on a shared filesystem). Removing locks may also be
     blocked by filesystem permissions.
 
     Returns 0 if no locks are held.
 
     """
 
     if opts.get('force_lock'):
         repo.svfs.unlink('lock')
     if opts.get('force_wlock'):
         repo.vfs.unlink('wlock')
     if opts.get('force_lock') or opts.get('force_lock'):
         return 0
 
     now = time.time()
     held = 0
 
     def report(vfs, name, method):
         # this causes stale locks to get reaped for more accurate reporting
         try:
             l = method(False)
         except error.LockHeld:
             l = None
 
         if l:
             l.release()
         else:
             try:
                 stat = vfs.lstat(name)
                 age = now - stat.st_mtime
                 user = util.username(stat.st_uid)
                 locker = vfs.readlock(name)
                 if ":" in locker:
                     host, pid = locker.split(':')
                     if host == socket.gethostname():
                         locker = 'user %s, process %s' % (user, pid)
                     else:
                         locker = 'user %s, process %s, host %s' \
                                  % (user, pid, host)
                 ui.write(("%-6s %s (%ds)\n") % (name + ":", locker, age))
                 return 1
             except OSError as e:
                 if e.errno != errno.ENOENT:
                     raise
 
         ui.write(("%-6s free\n") % (name + ":"))
         return 0
 
     held += report(repo.svfs, "lock", repo.lock)
     held += report(repo.vfs, "wlock", repo.wlock)
 
     return held
 
 @command('debugmergestate', [], '')
 def debugmergestate(ui, repo, *args):
     """print merge state
 
     Use --verbose to print out information about whether v1 or v2 merge state
     was chosen."""
     def _hashornull(h):
         if h == nullhex:
             return 'null'
         else:
             return h
 
     def printrecords(version):
         ui.write(('* version %s records\n') % version)
         if version == 1:
             records = v1records
         else:
             records = v2records
 
         for rtype, record in records:
             # pretty print some record types
             if rtype == 'L':
                 ui.write(('local: %s\n') % record)
             elif rtype == 'O':
                 ui.write(('other: %s\n') % record)
             elif rtype == 'm':
                 driver, mdstate = record.split('\0', 1)
                 ui.write(('merge driver: %s (state "%s")\n')
                          % (driver, mdstate))
             elif rtype in 'FDC':
                 r = record.split('\0')
                 f, state, hash, lfile, afile, anode, ofile = r[0:7]
                 if version == 1:
                     onode = 'not stored in v1 format'
                     flags = r[7]
                 else:
                     onode, flags = r[7:9]
                 ui.write(('file: %s (record type "%s", state "%s", hash %s)\n')
                          % (f, rtype, state, _hashornull(hash)))
                 ui.write(('  local path: %s (flags "%s")\n') % (lfile, flags))
                 ui.write(('  ancestor path: %s (node %s)\n')
                          % (afile, _hashornull(anode)))
                 ui.write(('  other path: %s (node %s)\n')
                          % (ofile, _hashornull(onode)))
             elif rtype == 'f':
                 filename, rawextras = record.split('\0', 1)
                 extras = rawextras.split('\0')
                 i = 0
                 extrastrings = []
                 while i < len(extras):
                     extrastrings.append('%s = %s' % (extras[i], extras[i + 1]))
                     i += 2
 
                 ui.write(('file extras: %s (%s)\n')
                          % (filename, ', '.join(extrastrings)))
             elif rtype == 'l':
                 labels = record.split('\0', 2)
                 labels = [l for l in labels if len(l) > 0]
                 ui.write(('labels:\n'))
                 ui.write(('  local: %s\n' % labels[0]))
                 ui.write(('  other: %s\n' % labels[1]))
                 if len(labels) > 2:
                     ui.write(('  base:  %s\n' % labels[2]))
             else:
                 ui.write(('unrecognized entry: %s\t%s\n')
                          % (rtype, record.replace('\0', '\t')))
 
     # Avoid mergestate.read() since it may raise an exception for unsupported
     # merge state records. We shouldn't be doing this, but this is OK since this
     # command is pretty low-level.
     ms = mergemod.mergestate(repo)
 
     # sort so that reasonable information is on top
     v1records = ms._readrecordsv1()
     v2records = ms._readrecordsv2()
     order = 'LOml'
     def key(r):
         idx = order.find(r[0])
         if idx == -1:
             return (1, r[1])
         else:
             return (0, idx)
     v1records.sort(key=key)
     v2records.sort(key=key)
 
     if not v1records and not v2records:
         ui.write(('no merge state found\n'))
     elif not v2records:
         ui.note(('no version 2 merge state\n'))
         printrecords(1)
     elif ms._v1v2match(v1records, v2records):
         ui.note(('v1 and v2 states match: using v2\n'))
         printrecords(2)
     else:
         ui.note(('v1 and v2 states mismatch: using v1\n'))
         printrecords(1)
         if ui.verbose:
             printrecords(2)
 
 @command('debugnamecomplete', [], _('NAME...'))
 def debugnamecomplete(ui, repo, *args):
     '''complete "names" - tags, open branch names, bookmark names'''
 
     names = set()
     # since we previously only listed open branches, we will handle that
     # specially (after this for loop)
     for name, ns in repo.names.iteritems():
         if name != 'branches':
             names.update(ns.listnames(repo))
     names.update(tag for (tag, heads, tip, closed)
                  in repo.branchmap().iterbranches() if not closed)
     completions = set()
     if not args:
         args = ['']
     for a in args:
         completions.update(n for n in names if n.startswith(a))
     ui.write('\n'.join(sorted(completions)))
     ui.write('\n')
 
 @command('debugobsolete',
         [('', 'flags', 0, _('markers flag')),
          ('', 'record-parents', False,
           _('record parent information for the precursor')),
          ('r', 'rev', [], _('display markers relevant to REV')),
          ('', 'index', False, _('display index of the marker')),
          ('', 'delete', [], _('delete markers specified by indices')),
         ] + commands.commitopts2 + commands.formatteropts,
          _('[OBSOLETED [REPLACEMENT ...]]'))
 def debugobsolete(ui, repo, precursor=None, *successors, **opts):
     """create arbitrary obsolete marker
 
     With no arguments, displays the list of obsolescence markers."""
 
     def parsenodeid(s):
         try:
             # We do not use revsingle/revrange functions here to accept
             # arbitrary node identifiers, possibly not present in the
             # local repository.
             n = bin(s)
             if len(n) != len(nullid):
                 raise TypeError()
             return n
         except TypeError:
             raise error.Abort('changeset references must be full hexadecimal '
                              'node identifiers')
 
     if opts.get('delete'):
         indices = []
         for v in opts.get('delete'):
             try:
                 indices.append(int(v))
             except ValueError:
                 raise error.Abort(_('invalid index value: %r') % v,
                                   hint=_('use integers for indices'))
 
         if repo.currenttransaction():
             raise error.Abort(_('cannot delete obsmarkers in the middle '
                                 'of transaction.'))
 
         with repo.lock():
             n = repair.deleteobsmarkers(repo.obsstore, indices)
             ui.write(_('deleted %i obsolescence markers\n') % n)
 
         return
 
     if precursor is not None:
         if opts['rev']:
             raise error.Abort('cannot select revision when creating marker')
         metadata = {}
         metadata['user'] = opts['user'] or ui.username()
         succs = tuple(parsenodeid(succ) for succ in successors)
         l = repo.lock()
         try:
             tr = repo.transaction('debugobsolete')
             try:
                 date = opts.get('date')
                 if date:
                     date = util.parsedate(date)
                 else:
                     date = None
                 prec = parsenodeid(precursor)
                 parents = None
                 if opts['record_parents']:
                     if prec not in repo.unfiltered():
                         raise error.Abort('cannot used --record-parents on '
                                          'unknown changesets')
                     parents = repo.unfiltered()[prec].parents()
                     parents = tuple(p.node() for p in parents)
                 repo.obsstore.create(tr, prec, succs, opts['flags'],
                                      parents=parents, date=date,
                                      metadata=metadata)
                 tr.close()
             except ValueError as exc:
                 raise error.Abort(_('bad obsmarker input: %s') % exc)
             finally:
                 tr.release()
         finally:
             l.release()
     else:
         if opts['rev']:
             revs = scmutil.revrange(repo, opts['rev'])
             nodes = [repo[r].node() for r in revs]
             markers = list(obsolete.getmarkers(repo, nodes=nodes))
             markers.sort(key=lambda x: x._data)
         else:
             markers = obsolete.getmarkers(repo)
 
         markerstoiter = markers
         isrelevant = lambda m: True
         if opts.get('rev') and opts.get('index'):
             markerstoiter = obsolete.getmarkers(repo)
             markerset = set(markers)
             isrelevant = lambda m: m in markerset
 
         fm = ui.formatter('debugobsolete', opts)
         for i, m in enumerate(markerstoiter):
             if not isrelevant(m):
                 # marker can be irrelevant when we're iterating over a set
                 # of markers (markerstoiter) which is bigger than the set
                 # of markers we want to display (markers)
                 # this can happen if both --index and --rev options are
                 # provided and thus we need to iterate over all of the markers
                 # to get the correct indices, but only display the ones that
                 # are relevant to --rev value
                 continue
             fm.startitem()
             ind = i if opts.get('index') else None
             cmdutil.showmarker(fm, m, index=ind)
         fm.end()
 
 @command('debugpathcomplete',
          [('f', 'full', None, _('complete an entire path')),
           ('n', 'normal', None, _('show only normal files')),
           ('a', 'added', None, _('show only added files')),
           ('r', 'removed', None, _('show only removed files'))],
          _('FILESPEC...'))
 def debugpathcomplete(ui, repo, *specs, **opts):
     '''complete part or all of a tracked path
 
     This command supports shells that offer path name completion. It
     currently completes only files already known to the dirstate.
 
     Completion extends only to the next path segment unless
     --full is specified, in which case entire paths are used.'''
 
     def complete(path, acceptable):
         dirstate = repo.dirstate
         spec = os.path.normpath(os.path.join(pycompat.getcwd(), path))
         rootdir = repo.root + pycompat.ossep
         if spec != repo.root and not spec.startswith(rootdir):
             return [], []
         if os.path.isdir(spec):
             spec += '/'
         spec = spec[len(rootdir):]
         fixpaths = pycompat.ossep != '/'
         if fixpaths:
             spec = spec.replace(pycompat.ossep, '/')
         speclen = len(spec)
         fullpaths = opts['full']
         files, dirs = set(), set()
         adddir, addfile = dirs.add, files.add
         for f, st in dirstate.iteritems():
             if f.startswith(spec) and st[0] in acceptable:
                 if fixpaths:
                     f = f.replace('/', pycompat.ossep)
                 if fullpaths:
                     addfile(f)
                     continue
                 s = f.find(pycompat.ossep, speclen)
                 if s >= 0:
                     adddir(f[:s])
                 else:
                     addfile(f)
         return files, dirs
 
     acceptable = ''
     if opts['normal']:
         acceptable += 'nm'
     if opts['added']:
         acceptable += 'a'
     if opts['removed']:
         acceptable += 'r'
     cwd = repo.getcwd()
     if not specs:
         specs = ['.']
 
     files, dirs = set(), set()
     for spec in specs:
         f, d = complete(spec, acceptable or 'nmar')
         files.update(f)
         dirs.update(d)
     files.update(dirs)
     ui.write('\n'.join(repo.pathto(p, cwd) for p in sorted(files)))
     ui.write('\n')
 
 @command('debugpushkey', [], _('REPO NAMESPACE [KEY OLD NEW]'), norepo=True)
 def debugpushkey(ui, repopath, namespace, *keyinfo, **opts):
     '''access the pushkey key/value protocol
 
     With two args, list the keys in the given namespace.
 
     With five args, set a key to new if it currently is set to old.
     Reports success or failure.
     '''
 
     target = hg.peer(ui, {}, repopath)
     if keyinfo:
         key, old, new = keyinfo
         r = target.pushkey(namespace, key, old, new)
         ui.status(str(r) + '\n')
         return not r
     else:
         for k, v in sorted(target.listkeys(namespace).iteritems()):
             ui.write("%s\t%s\n" % (util.escapestr(k),
                                    util.escapestr(v)))
 
 @command('debugpvec', [], _('A B'))
 def debugpvec(ui, repo, a, b=None):
     ca = scmutil.revsingle(repo, a)
     cb = scmutil.revsingle(repo, b)
     pa = pvec.ctxpvec(ca)
     pb = pvec.ctxpvec(cb)
     if pa == pb:
         rel = "="
     elif pa > pb:
         rel = ">"
     elif pa < pb:
         rel = "<"
     elif pa | pb:
         rel = "|"
     ui.write(_("a: %s\n") % pa)
     ui.write(_("b: %s\n") % pb)
     ui.write(_("depth(a): %d depth(b): %d\n") % (pa._depth, pb._depth))
     ui.write(_("delta: %d hdist: %d distance: %d relation: %s\n") %
              (abs(pa._depth - pb._depth), pvec._hamming(pa._vec, pb._vec),
               pa.distance(pb), rel))
 
 @command('debugrebuilddirstate|debugrebuildstate',
     [('r', 'rev', '', _('revision to rebuild to'), _('REV')),
      ('', 'minimal', None, _('only rebuild files that are inconsistent with '
                              'the working copy parent')),
     ],
     _('[-r REV]'))
 def debugrebuilddirstate(ui, repo, rev, **opts):
     """rebuild the dirstate as it would look like for the given revision
 
     If no revision is specified the first current parent will be used.
 
     The dirstate will be set to the files of the given revision.
     The actual working directory content or existing dirstate
     information such as adds or removes is not considered.
 
     ``minimal`` will only rebuild the dirstate status for files that claim to be
     tracked but are not in the parent manifest, or that exist in the parent
     manifest but are not in the dirstate. It will not change adds, removes, or
     modified files that are in the working copy parent.
 
     One use of this command is to make the next :hg:`status` invocation
     check the actual file content.
     """
     ctx = scmutil.revsingle(repo, rev)
     with repo.wlock():
         dirstate = repo.dirstate
         changedfiles = None
         # See command doc for what minimal does.
         if opts.get('minimal'):
             manifestfiles = set(ctx.manifest().keys())
             dirstatefiles = set(dirstate)
             manifestonly = manifestfiles - dirstatefiles
             dsonly = dirstatefiles - manifestfiles
             dsnotadded = set(f for f in dsonly if dirstate[f] != 'a')
             changedfiles = manifestonly | dsnotadded
 
         dirstate.rebuild(ctx.node(), ctx.manifest(), changedfiles)
 
 @command('debugrebuildfncache', [], '')
 def debugrebuildfncache(ui, repo):
     """rebuild the fncache file"""
     repair.rebuildfncache(ui, repo)
 
 @command('debugrename',
     [('r', 'rev', '', _('revision to debug'), _('REV'))],
     _('[-r REV] FILE'))
 def debugrename(ui, repo, file1, *pats, **opts):
     """dump rename information"""
 
     ctx = scmutil.revsingle(repo, opts.get('rev'))
     m = scmutil.match(ctx, (file1,) + pats, opts)
     for abs in ctx.walk(m):
         fctx = ctx[abs]
         o = fctx.filelog().renamed(fctx.filenode())
         rel = m.rel(abs)
         if o:
             ui.write(_("%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
         else:
             ui.write(_("%s not renamed\n") % rel)
 
 @command('debugrevlog', commands.debugrevlogopts +
     [('d', 'dump', False, _('dump index data'))],
     _('-c|-m|FILE'),
     optionalrepo=True)
 def debugrevlog(ui, repo, file_=None, **opts):
     """show data and statistics about a revlog"""
     r = cmdutil.openrevlog(repo, 'debugrevlog', file_, opts)
 
     if opts.get("dump"):
         numrevs = len(r)
         ui.write(("# rev p1rev p2rev start   end deltastart base   p1   p2"
                  " rawsize totalsize compression heads chainlen\n"))
         ts = 0
         heads = set()
 
         for rev in xrange(numrevs):
             dbase = r.deltaparent(rev)
             if dbase == -1:
                 dbase = rev
             cbase = r.chainbase(rev)
             clen = r.chainlen(rev)
             p1, p2 = r.parentrevs(rev)
             rs = r.rawsize(rev)
             ts = ts + rs
             heads -= set(r.parentrevs(rev))
             heads.add(rev)
             try:
                 compression = ts / r.end(rev)
             except ZeroDivisionError:
                 compression = 0
             ui.write("%5d %5d %5d %5d %5d %10d %4d %4d %4d %7d %9d "
                      "%11d %5d %8d\n" %
                      (rev, p1, p2, r.start(rev), r.end(rev),
                       r.start(dbase), r.start(cbase),
                       r.start(p1), r.start(p2),
                       rs, ts, compression, len(heads), clen))
         return 0
 
     v = r.version
     format = v & 0xFFFF
     flags = []
     gdelta = False
     if v & revlog.REVLOGNGINLINEDATA:
         flags.append('inline')
     if v & revlog.REVLOGGENERALDELTA:
         gdelta = True
         flags.append('generaldelta')
     if not flags:
         flags = ['(none)']
 
     nummerges = 0
     numfull = 0
     numprev = 0
     nump1 = 0
     nump2 = 0
     numother = 0
     nump1prev = 0
     nump2prev = 0
     chainlengths = []
 
     datasize = [None, 0, 0]
     fullsize = [None, 0, 0]
     deltasize = [None, 0, 0]
     chunktypecounts = {}
     chunktypesizes = {}
 
     def addsize(size, l):
         if l[0] is None or size < l[0]:
             l[0] = size
         if size > l[1]:
             l[1] = size
         l[2] += size
 
     numrevs = len(r)
     for rev in xrange(numrevs):
         p1, p2 = r.parentrevs(rev)
         delta = r.deltaparent(rev)
         if format > 0:
             addsize(r.rawsize(rev), datasize)
         if p2 != nullrev:
             nummerges += 1
         size = r.length(rev)
         if delta == nullrev:
             chainlengths.append(0)
             numfull += 1
             addsize(size, fullsize)
         else:
             chainlengths.append(chainlengths[delta] + 1)
             addsize(size, deltasize)
             if delta == rev - 1:
                 numprev += 1
                 if delta == p1:
                     nump1prev += 1
                 elif delta == p2:
                     nump2prev += 1
             elif delta == p1:
                 nump1 += 1
             elif delta == p2:
                 nump2 += 1
             elif delta != nullrev:
                 numother += 1
 
         # Obtain data on the raw chunks in the revlog.
         chunk = r._chunkraw(rev, rev)[1]
         if chunk:
             chunktype = chunk[0]
         else:
             chunktype = 'empty'
 
         if chunktype not in chunktypecounts:
             chunktypecounts[chunktype] = 0
             chunktypesizes[chunktype] = 0
 
         chunktypecounts[chunktype] += 1
         chunktypesizes[chunktype] += size
 
     # Adjust size min value for empty cases
     for size in (datasize, fullsize, deltasize):
         if size[0] is None:
             size[0] = 0
 
     numdeltas = numrevs - numfull
     numoprev = numprev - nump1prev - nump2prev
     totalrawsize = datasize[2]
     datasize[2] /= numrevs
     fulltotal = fullsize[2]
     fullsize[2] /= numfull
     deltatotal = deltasize[2]
     if numrevs - numfull > 0:
         deltasize[2] /= numrevs - numfull
     totalsize = fulltotal + deltatotal
     avgchainlen = sum(chainlengths) / numrevs
     maxchainlen = max(chainlengths)
     compratio = 1
     if totalsize:
         compratio = totalrawsize / totalsize
 
     basedfmtstr = '%%%dd\n'
     basepcfmtstr = '%%%dd %s(%%5.2f%%%%)\n'
 
     def dfmtstr(max):
         return basedfmtstr % len(str(max))
     def pcfmtstr(max, padding=0):
         return basepcfmtstr % (len(str(max)), ' ' * padding)
 
     def pcfmt(value, total):
         if total:
             return (value, 100 * float(value) / total)
         else:
             return value, 100.0
 
     ui.write(('format : %d\n') % format)
     ui.write(('flags  : %s\n') % ', '.join(flags))
 
     ui.write('\n')
     fmt = pcfmtstr(totalsize)
     fmt2 = dfmtstr(totalsize)
     ui.write(('revisions     : ') + fmt2 % numrevs)
     ui.write(('    merges    : ') + fmt % pcfmt(nummerges, numrevs))
     ui.write(('    normal    : ') + fmt % pcfmt(numrevs - nummerges, numrevs))
     ui.write(('revisions     : ') + fmt2 % numrevs)
     ui.write(('    full      : ') + fmt % pcfmt(numfull, numrevs))
     ui.write(('    deltas    : ') + fmt % pcfmt(numdeltas, numrevs))
     ui.write(('revision size : ') + fmt2 % totalsize)
     ui.write(('    full      : ') + fmt % pcfmt(fulltotal, totalsize))
     ui.write(('    deltas    : ') + fmt % pcfmt(deltatotal, totalsize))
 
     def fmtchunktype(chunktype):
         if chunktype == 'empty':
             return '    %s     : ' % chunktype
         elif chunktype in string.ascii_letters:
             return '    0x%s (%s)  : ' % (hex(chunktype), chunktype)
         else:
             return '    0x%s      : ' % hex(chunktype)
 
     ui.write('\n')
     ui.write(('chunks        : ') + fmt2 % numrevs)
     for chunktype in sorted(chunktypecounts):
         ui.write(fmtchunktype(chunktype))
         ui.write(fmt % pcfmt(chunktypecounts[chunktype], numrevs))
     ui.write(('chunks size   : ') + fmt2 % totalsize)
     for chunktype in sorted(chunktypecounts):
         ui.write(fmtchunktype(chunktype))
         ui.write(fmt % pcfmt(chunktypesizes[chunktype], totalsize))
 
     ui.write('\n')
     fmt = dfmtstr(max(avgchainlen, compratio))
     ui.write(('avg chain length  : ') + fmt % avgchainlen)
     ui.write(('max chain length  : ') + fmt % maxchainlen)
     ui.write(('compression ratio : ') + fmt % compratio)
 
     if format > 0:
         ui.write('\n')
         ui.write(('uncompressed data size (min/max/avg) : %d / %d / %d\n')
                  % tuple(datasize))
     ui.write(('full revision size (min/max/avg)     : %d / %d / %d\n')
              % tuple(fullsize))
     ui.write(('delta size (min/max/avg)             : %d / %d / %d\n')
              % tuple(deltasize))
 
     if numdeltas > 0:
         ui.write('\n')
         fmt = pcfmtstr(numdeltas)
         fmt2 = pcfmtstr(numdeltas, 4)
         ui.write(('deltas against prev  : ') + fmt % pcfmt(numprev, numdeltas))
         if numprev > 0:
             ui.write(('    where prev = p1  : ') + fmt2 % pcfmt(nump1prev,
                                                               numprev))
             ui.write(('    where prev = p2  : ') + fmt2 % pcfmt(nump2prev,
                                                               numprev))
             ui.write(('    other            : ') + fmt2 % pcfmt(numoprev,
                                                               numprev))
         if gdelta:
             ui.write(('deltas against p1    : ')
                      + fmt % pcfmt(nump1, numdeltas))
             ui.write(('deltas against p2    : ')
                      + fmt % pcfmt(nump2, numdeltas))
             ui.write(('deltas against other : ') + fmt % pcfmt(numother,
                                                              numdeltas))
 
 @command('debugrevspec',
     [('', 'optimize', None,
       _('print parsed tree after optimizing (DEPRECATED)')),
      ('p', 'show-stage', [],
       _('print parsed tree at the given stage'), _('NAME')),
      ('', 'no-optimized', False, _('evaluate tree without optimization')),
      ('', 'verify-optimized', False, _('verify optimized result')),
      ],
     ('REVSPEC'))
 def debugrevspec(ui, repo, expr, **opts):
     """parse and apply a revision specification
 
     Use -p/--show-stage option to print the parsed tree at the given stages.
     Use -p all to print tree at every stage.
 
     Use --verify-optimized to compare the optimized result with the unoptimized
     one. Returns 1 if the optimized result differs.
     """
     stages = [
         ('parsed', lambda tree: tree),
         ('expanded', lambda tree: revsetlang.expandaliases(ui, tree)),
         ('concatenated', revsetlang.foldconcat),
         ('analyzed', revsetlang.analyze),
         ('optimized', revsetlang.optimize),
     ]
     if opts['no_optimized']:
         stages = stages[:-1]
     if opts['verify_optimized'] and opts['no_optimized']:
         raise error.Abort(_('cannot use --verify-optimized with '
                             '--no-optimized'))
     stagenames = set(n for n, f in stages)
 
     showalways = set()
     showchanged = set()
     if ui.verbose and not opts['show_stage']:
         # show parsed tree by --verbose (deprecated)
         showalways.add('parsed')
         showchanged.update(['expanded', 'concatenated'])
         if opts['optimize']:
             showalways.add('optimized')
     if opts['show_stage'] and opts['optimize']:
         raise error.Abort(_('cannot use --optimize with --show-stage'))
     if opts['show_stage'] == ['all']:
         showalways.update(stagenames)
     else:
         for n in opts['show_stage']:
             if n not in stagenames:
                 raise error.Abort(_('invalid stage name: %s') % n)
         showalways.update(opts['show_stage'])
 
     treebystage = {}
     printedtree = None
     tree = revsetlang.parse(expr, lookup=repo.__contains__)
     for n, f in stages:
         treebystage[n] = tree = f(tree)
         if n in showalways or (n in showchanged and tree != printedtree):
             if opts['show_stage'] or n != 'parsed':
                 ui.write(("* %s:\n") % n)
             ui.write(revsetlang.prettyformat(tree), "\n")
             printedtree = tree
 
     if opts['verify_optimized']:
         arevs = revset.makematcher(treebystage['analyzed'])(repo)
         brevs = revset.makematcher(treebystage['optimized'])(repo)
         if ui.verbose:
             ui.note(("* analyzed set:\n"), smartset.prettyformat(arevs), "\n")
             ui.note(("* optimized set:\n"), smartset.prettyformat(brevs), "\n")
         arevs = list(arevs)
         brevs = list(brevs)
         if arevs == brevs:
             return 0
         ui.write(('--- analyzed\n'), label='diff.file_a')
         ui.write(('+++ optimized\n'), label='diff.file_b')
         sm = difflib.SequenceMatcher(None, arevs, brevs)
         for tag, alo, ahi, blo, bhi in sm.get_opcodes():
             if tag in ('delete', 'replace'):
                 for c in arevs[alo:ahi]:
                     ui.write('-%s\n' % c, label='diff.deleted')
             if tag in ('insert', 'replace'):
                 for c in brevs[blo:bhi]:
                     ui.write('+%s\n' % c, label='diff.inserted')
             if tag == 'equal':
                 for c in arevs[alo:ahi]:
                     ui.write(' %s\n' % c)
         return 1
 
     func = revset.makematcher(tree)
     revs = func(repo)
     if ui.verbose:
         ui.note(("* set:\n"), smartset.prettyformat(revs), "\n")
     for c in revs:
         ui.write("%s\n" % c)
 
 @command('debugsetparents', [], _('REV1 [REV2]'))
 def debugsetparents(ui, repo, rev1, rev2=None):
     """manually set the parents of the current working directory
 
     This is useful for writing repository conversion tools, but should
     be used with care. For example, neither the working directory nor the
     dirstate is updated, so file status may be incorrect after running this
     command.
 
     Returns 0 on success.
     """
 
     r1 = scmutil.revsingle(repo, rev1).node()
     r2 = scmutil.revsingle(repo, rev2, 'null').node()
 
     with repo.wlock():
         repo.setparents(r1, r2)
 
 @command('debugsub',
     [('r', 'rev', '',
      _('revision to check'), _('REV'))],
     _('[-r REV] [REV]'))
 def debugsub(ui, repo, rev=None):
     ctx = scmutil.revsingle(repo, rev, None)
     for k, v in sorted(ctx.substate.items()):
         ui.write(('path %s\n') % k)
         ui.write((' source   %s\n') % v[0])
         ui.write((' revision %s\n') % v[1])
 
 @command('debugsuccessorssets',
     [],
     _('[REV]'))
 def debugsuccessorssets(ui, repo, *revs):
     """show set of successors for revision
 
     A successors set of changeset A is a consistent group of revisions that
     succeed A. It contains non-obsolete changesets only.
 
     In most cases a changeset A has a single successors set containing a single
     successor (changeset A replaced by A').
 
     A changeset that is made obsolete with no successors are called "pruned".
     Such changesets have no successors sets at all.
 
     A changeset that has been "split" will have a successors set containing
     more than one successor.
 
     A changeset that has been rewritten in multiple different ways is called
     "divergent". Such changesets have multiple successor sets (each of which
     may also be split, i.e. have multiple successors).
 
     Results are displayed as follows::
 
         <rev1>
             <successors-1A>
         <rev2>
             <successors-2A>
             <successors-2B1> <successors-2B2> <successors-2B3>
 
     Here rev2 has two possible (i.e. divergent) successors sets. The first
     holds one element, whereas the second holds three (i.e. the changeset has
     been split).
     """
     # passed to successorssets caching computation from one call to another
     cache = {}
     ctx2str = str
     node2str = short
     if ui.debug():
         def ctx2str(ctx):
             return ctx.hex()
         node2str = hex
     for rev in scmutil.revrange(repo, revs):
         ctx = repo[rev]
         ui.write('%s\n'% ctx2str(ctx))
         for succsset in obsolete.successorssets(repo, ctx.node(), cache):
             if succsset:
                 ui.write('    ')
                 ui.write(node2str(succsset[0]))
                 for node in succsset[1:]:
                     ui.write(' ')
                     ui.write(node2str(node))
             ui.write('\n')
 
 @command('debugtemplate',
     [('r', 'rev', [], _('apply template on changesets'), _('REV')),
      ('D', 'define', [], _('define template keyword'), _('KEY=VALUE'))],
     _('[-r REV]... [-D KEY=VALUE]... TEMPLATE'),
     optionalrepo=True)
 def debugtemplate(ui, repo, tmpl, **opts):
     """parse and apply a template
 
     If -r/--rev is given, the template is processed as a log template and
     applied to the given changesets. Otherwise, it is processed as a generic
     template.
 
     Use --verbose to print the parsed tree.
     """
     revs = None
     if opts['rev']:
         if repo is None:
             raise error.RepoError(_('there is no Mercurial repository here '
                                     '(.hg not found)'))
         revs = scmutil.revrange(repo, opts['rev'])
 
     props = {}
     for d in opts['define']:
         try:
             k, v = (e.strip() for e in d.split('=', 1))
             if not k or k == 'ui':
                 raise ValueError
             props[k] = v
         except ValueError:
             raise error.Abort(_('malformed keyword definition: %s') % d)
 
     if ui.verbose:
         aliases = ui.configitems('templatealias')
         tree = templater.parse(tmpl)
         ui.note(templater.prettyformat(tree), '\n')
         newtree = templater.expandaliases(tree, aliases)
         if newtree != tree:
             ui.note(("* expanded:\n"), templater.prettyformat(newtree), '\n')
 
     mapfile = None
     if revs is None:
         k = 'debugtemplate'
         t = formatter.maketemplater(ui, k, tmpl)
         ui.write(templater.stringify(t(k, ui=ui, **props)))
     else:
         displayer = cmdutil.changeset_templater(ui, repo, None, opts, tmpl,
                                                 mapfile, buffered=False)
         for r in revs:
             displayer.show(repo[r], **props)
         displayer.close()
 
 @command('debugupgraderepo', [
     ('o', 'optimize', [], _('extra optimization to perform'), _('NAME')),
     ('', 'run', False, _('performs an upgrade')),
 ])
 def debugupgraderepo(ui, repo, run=False, optimize=None):
     """upgrade a repository to use different features
 
     If no arguments are specified, the repository is evaluated for upgrade
     and a list of problems and potential optimizations is printed.
 
     With ``--run``, a repository upgrade is performed. Behavior of the upgrade
     can be influenced via additional arguments. More details will be provided
     by the command output when run without ``--run``.
 
     During the upgrade, the repository will be locked and no writes will be
     allowed.
 
     At the end of the upgrade, the repository may not be readable while new
     repository data is swapped in. This window will be as long as it takes to
     rename some directories inside the ``.hg`` directory. On most machines, this
     should complete almost instantaneously and the chances of a consumer being
     unable to access the repository should be low.
     """
-    return repair.upgraderepo(ui, repo, run=run, optimize=optimize)
+    return upgrade.upgraderepo(ui, repo, run=run, optimize=optimize)
 
 @command('debugwalk', commands.walkopts, _('[OPTION]... [FILE]...'),
          inferrepo=True)
 def debugwalk(ui, repo, *pats, **opts):
     """show how files match on given patterns"""
     m = scmutil.match(repo[None], pats, opts)
     items = list(repo.walk(m))
     if not items:
         return
     f = lambda fn: fn
     if ui.configbool('ui', 'slash') and pycompat.ossep != '/':
         f = lambda fn: util.normpath(fn)
     fmt = 'f  %%-%ds  %%-%ds  %%s' % (
         max([len(abs) for abs in items]),
         max([len(m.rel(abs)) for abs in items]))
     for abs in items:
         line = fmt % (abs, f(m.rel(abs)), m.exact(abs) and 'exact' or '')
         ui.write("%s\n" % line.rstrip())
 
 @command('debugwireargs',
     [('', 'three', '', 'three'),
     ('', 'four', '', 'four'),
     ('', 'five', '', 'five'),
     ] + commands.remoteopts,
     _('REPO [OPTIONS]... [ONE [TWO]]'),
     norepo=True)
 def debugwireargs(ui, repopath, *vals, **opts):
     repo = hg.peer(ui, opts, repopath)
     for opt in commands.remoteopts:
         del opts[opt[1]]
     args = {}
     for k, v in opts.iteritems():
         if v:
             args[k] = v
     # run twice to check that we don't mess up the stream for the next command
     res1 = repo.debugwireargs(*vals, **args)
     res2 = repo.debugwireargs(*vals, **args)
     ui.write("%s\n" % res1)
     if res1 != res2:
         ui.warn("%s\n" % res2)

mercurial/repair.py

@@ -1,1096 +1,354
 # 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
 import hashlib
-import stat
-import tempfile
 
 from .i18n import _
 from .node import short
 from . import (
     bundle2,
     changegroup,
-    changelog,
     error,
     exchange,
-    manifest,
     obsolete,
-    revlog,
-    scmutil,
     util,
-    vfs as vfsmod,
 )
 
 def _bundle(repo, bases, heads, node, suffix, compress=True):
     """create a bundle with the specified revisions as a backup"""
     cgversion = changegroup.safeversion(repo)
 
     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 = hashlib.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 bundle2.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.manifestlog._revlog)
     for fname in files:
         collectone(repo.file(fname))
 
     return s
 
 def strip(ui, repo, nodelist, backup=True, topic='backup'):
     # This function operates within a transaction of its own, but does
     # not take any lock on the repo.
     # 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)
 
     files = _collectfiles(repo, striprev)
     saverevs = _collectbrokencsets(repo, files, striprev)
 
     # 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)
     saveheads = set(saverevs)
     for r in cl.revs(start=striprev + 1):
         if any(p in tostrip for p in cl.parentrevs(r)):
             tostrip.add(r)
 
         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))
     tmpbundlefile = None
     if saveheads:
         # do not compress temporary bundle if we remove it from disk later
         tmpbundlefile = _bundle(repo, savebases, saveheads, node, 'temp',
                             compress=False)
 
     mfst = repo.manifestlog._revlog
 
     curtr = repo.currenttransaction()
     if curtr is not None:
         del curtr  # avoid carrying reference to transaction for nothing
         raise error.ProgrammingError('cannot strip from inside a transaction')
 
     try:
         with repo.transaction("strip") as tr:
             offset = len(tr.entries)
 
             tr.startgroup()
             cl.strip(striprev, tr)
             mfst.strip(striprev, tr)
             if 'treemanifest' in repo.requirements: # safe but unnecessary
                                                     # otherwise
                 for unencoded, encoded, size in repo.store.datafiles():
                     if (unencoded.startswith('meta/') and
                         unencoded.endswith('00manifest.i')):
                         dir = unencoded[5:-12]
                         repo.manifestlog._revlog.dirlog(dir).strip(striprev, tr)
             for fn in files:
                 repo.file(fn).strip(striprev, tr)
             tr.endgroup()
 
             for i in xrange(offset, len(tr.entries)):
                 file, troffset, ignore = tr.entries[i]
                 with repo.svfs(file, 'a', checkambig=True) as fp:
                     fp.truncate(troffset)
                 if troffset == 0:
                     repo.store.markremoved(file)
 
         if tmpbundlefile:
             ui.note(_("adding branch\n"))
             f = vfs.open(tmpbundlefile, "rb")
             gen = exchange.readbundle(ui, f, tmpbundlefile, vfs)
             if not repo.ui.verbose:
                 # silence internal shuffling chatter
                 repo.ui.pushbuffer()
             if isinstance(gen, bundle2.unbundle20):
                 with repo.transaction('strip') as tr:
                     tr.hookargs = {'source': 'strip',
                                    'url': 'bundle:' + vfs.join(tmpbundlefile)}
                     bundle2.applybundle(repo, gen, tr, source='strip',
                                         url='bundle:' + vfs.join(tmpbundlefile))
             else:
                 gen.apply(repo, 'strip', 'bundle:' + vfs.join(tmpbundlefile),
                           True)
             if not repo.ui.verbose:
                 repo.ui.popbuffer()
             f.close()
         repo._phasecache.invalidate()
 
         for m in updatebm:
             bm[m] = repo[newbmtarget].node()
 
         with repo.lock():
             with repo.transaction('repair') as tr:
                 bm.recordchange(tr)
 
         # 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)))
 
     except: # re-raises
         if backupfile:
             ui.warn(_("strip failed, backup bundle stored in '%s'\n")
                     % vfs.join(backupfile))
         if tmpbundlefile:
             ui.warn(_("strip failed, unrecovered changes stored in '%s'\n")
                     % vfs.join(tmpbundlefile))
             ui.warn(_("(fix the problem, then recover the changesets with "
                       "\"hg unbundle '%s'\")\n") % vfs.join(tmpbundlefile))
         raise
     else:
         if tmpbundlefile:
             # Remove temporary bundle only if there were no exceptions
             vfs.unlink(tmpbundlefile)
 
     repo.destroyed()
     # return the backup file path (or None if 'backup' was False) so
     # extensions can use it
     return backupfile
 
 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
 
     with repo.lock():
         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(_('rebuilding'), rev, total=repolen,
                         unit=_('changesets'))
 
             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(_('rebuilding'), None)
 
         if 'treemanifest' in repo.requirements: # safe but unnecessary otherwise
             for dir in util.dirs(seenfiles):
                 i = 'meta/%s/00manifest.i' % dir
                 d = 'meta/%s/00manifest.d' % dir
 
                 if repo.store._exists(i):
                     newentries.add(i)
                 if repo.store._exists(d):
                     newentries.add(d)
 
         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
 
             with repo.transaction('fncache') as tr:
                 fnc.write(tr)
         else:
             ui.write(_('fncache already up to date\n'))
 
 def stripbmrevset(repo, mark):
     """
     The revset to strip when strip is called with -B mark
 
     Needs to live here so extensions can use it and wrap it even when strip is
     not enabled or not present on a box.
     """
     return repo.revs("ancestors(bookmark(%s)) - "
                      "ancestors(head() and not bookmark(%s)) - "
                      "ancestors(bookmark() and not bookmark(%s))",
                      mark, mark, mark)
 
 def deleteobsmarkers(obsstore, indices):
     """Delete some obsmarkers from obsstore and return how many were deleted
 
     'indices' is a list of ints which are the indices
     of the markers to be deleted.
 
     Every invocation of this function completely rewrites the obsstore file,
     skipping the markers we want to be removed. The new temporary file is
     created, remaining markers are written there and on .close() this file
     gets atomically renamed to obsstore, thus guaranteeing consistency."""
     if not indices:
         # we don't want to rewrite the obsstore with the same content
         return
 
     left = []
     current = obsstore._all
     n = 0
     for i, m in enumerate(current):
         if i in indices:
             n += 1
             continue
         left.append(m)
 
     newobsstorefile = obsstore.svfs('obsstore', 'w', atomictemp=True)
     for bytes in obsolete.encodemarkers(left, True, obsstore._version):
         newobsstorefile.write(bytes)
     newobsstorefile.close()
     return n
-
-def upgraderequiredsourcerequirements(repo):
-    """Obtain requirements required to be present to upgrade a repo.
-
-    An upgrade will not be allowed if the repository doesn't have the
-    requirements returned by this function.
-    """
-    return set([
-        # Introduced in Mercurial 0.9.2.
-        'revlogv1',
-        # Introduced in Mercurial 0.9.2.
-        'store',
-    ])
-
-def upgradeblocksourcerequirements(repo):
-    """Obtain requirements that will prevent an upgrade from occurring.
-
-    An upgrade cannot be performed if the source repository contains a
-    requirements in the returned set.
-    """
-    return set([
-        # The upgrade code does not yet support these experimental features.
-        # This is an artificial limitation.
-        'manifestv2',
-        'treemanifest',
-        # This was a precursor to generaldelta and was never enabled by default.
-        # It should (hopefully) not exist in the wild.
-        'parentdelta',
-        # Upgrade should operate on the actual store, not the shared link.
-        'shared',
-    ])
-
-def upgradesupportremovedrequirements(repo):
-    """Obtain requirements that can be removed during an upgrade.
-
-    If an upgrade were to create a repository that dropped a requirement,
-    the dropped requirement must appear in the returned set for the upgrade
-    to be allowed.
-    """
-    return set()
-
-def upgradesupporteddestrequirements(repo):
-    """Obtain requirements that upgrade supports in the destination.
-
-    If the result of the upgrade would create requirements not in this set,
-    the upgrade is disallowed.
-
-    Extensions should monkeypatch this to add their custom requirements.
-    """
-    return set([
-        'dotencode',
-        'fncache',
-        'generaldelta',
-        'revlogv1',
-        'store',
-    ])
-
-def upgradeallowednewrequirements(repo):
-    """Obtain requirements that can be added to a repository during upgrade.
-
-    This is used to disallow proposed requirements from being added when
-    they weren't present before.
-
-    We use a list of allowed requirement additions instead of a list of known
-    bad additions because the whitelist approach is safer and will prevent
-    future, unknown requirements from accidentally being added.
-    """
-    return set([
-        'dotencode',
-        'fncache',
-        'generaldelta',
-    ])
-
-deficiency = 'deficiency'
-optimisation = 'optimization'
-
-class upgradeimprovement(object):
-    """Represents an improvement that can be made as part of an upgrade.
-
-    The following attributes are defined on each instance:
-
-    name
-       Machine-readable string uniquely identifying this improvement. It
-       will be mapped to an action later in the upgrade process.
-
-    type
-       Either ``deficiency`` or ``optimisation``. A deficiency is an obvious
-       problem. An optimization is an action (sometimes optional) that
-       can be taken to further improve the state of the repository.
-
-    description
-       Message intended for humans explaining the improvement in more detail,
-       including the implications of it. For ``deficiency`` types, should be
-       worded in the present tense. For ``optimisation`` types, should be
-       worded in the future tense.
-
-    upgrademessage
-       Message intended for humans explaining what an upgrade addressing this
-       issue will do. Should be worded in the future tense.
-
-    fromdefault (``deficiency`` types only)
-       Boolean indicating whether the current (deficient) state deviates
-       from Mercurial's default configuration.
-
-    fromconfig (``deficiency`` types only)
-       Boolean indicating whether the current (deficient) state deviates
-       from the current Mercurial configuration.
-    """
-    def __init__(self, name, type, description, upgrademessage, **kwargs):
-        self.name = name
-        self.type = type
-        self.description = description
-        self.upgrademessage = upgrademessage
-
-        for k, v in kwargs.items():
-            setattr(self, k, v)
-
-def upgradefindimprovements(repo):
-    """Determine improvements that can be made to the repo during upgrade.
-
-    Returns a list of ``upgradeimprovement`` describing repository deficiencies
-    and optimizations.
-    """
-    # Avoid cycle: cmdutil -> repair -> localrepo -> cmdutil
-    from . import localrepo
-
-    newreporeqs = localrepo.newreporequirements(repo)
-
-    improvements = []
-
-    # We could detect lack of revlogv1 and store here, but they were added
-    # in 0.9.2 and we don't support upgrading repos without these
-    # requirements, so let's not bother.
-
-    if 'fncache' not in repo.requirements:
-        improvements.append(upgradeimprovement(
-            name='fncache',
-            type=deficiency,
-            description=_('long and reserved filenames may not work correctly; '
-                          'repository performance is sub-optimal'),
-            upgrademessage=_('repository will be more resilient to storing '
-                             'certain paths and performance of certain '
-                             'operations should be improved'),
-            fromdefault=True,
-            fromconfig='fncache' in newreporeqs))
-
-    if 'dotencode' not in repo.requirements:
-        improvements.append(upgradeimprovement(
-            name='dotencode',
-            type=deficiency,
-            description=_('storage of filenames beginning with a period or '
-                          'space may not work correctly'),
-            upgrademessage=_('repository will be better able to store files '
-                             'beginning with a space or period'),
-            fromdefault=True,
-            fromconfig='dotencode' in newreporeqs))
-
-    if 'generaldelta' not in repo.requirements:
-        improvements.append(upgradeimprovement(
-            name='generaldelta',
-            type=deficiency,
-            description=_('deltas within internal storage are unable to '
-                          'choose optimal revisions; repository is larger and '
-                          'slower than it could be; interaction with other '
-                          'repositories may require extra network and CPU '
-                          'resources, making "hg push" and "hg pull" slower'),
-            upgrademessage=_('repository storage will be able to create '
-                             'optimal deltas; new repository data will be '
-                             'smaller and read times should decrease; '
-                             'interacting with other repositories using this '
-                             'storage model should require less network and '
-                             'CPU resources, making "hg push" and "hg pull" '
-                             'faster'),
-            fromdefault=True,
-            fromconfig='generaldelta' in newreporeqs))
-
-    # Mercurial 4.0 changed changelogs to not use delta chains. Search for
-    # changelogs with deltas.
-    cl = repo.changelog
-    for rev in cl:
-        chainbase = cl.chainbase(rev)
-        if chainbase != rev:
-            improvements.append(upgradeimprovement(
-                name='removecldeltachain',
-                type=deficiency,
-                description=_('changelog storage is using deltas instead of '
-                              'raw entries; changelog reading and any '
-                              'operation relying on changelog data are slower '
-                              'than they could be'),
-                upgrademessage=_('changelog storage will be reformated to '
-                                 'store raw entries; changelog reading will be '
-                                 'faster; changelog size may be reduced'),
-                fromdefault=True,
-                fromconfig=True))
-            break
-
-    # Now for the optimizations.
-
-    # These are unconditionally added. There is logic later that figures out
-    # which ones to apply.
-
-    improvements.append(upgradeimprovement(
-        name='redeltaparent',
-        type=optimisation,
-        description=_('deltas within internal storage will be recalculated to '
-                      'choose an optimal base revision where this was not '
-                      'already done; the size of the repository may shrink and '
-                      'various operations may become faster; the first time '
-                      'this optimization is performed could slow down upgrade '
-                      'execution considerably; subsequent invocations should '
-                      'not run noticeably slower'),
-        upgrademessage=_('deltas within internal storage will choose a new '
-                         'base revision if needed')))
-
-    improvements.append(upgradeimprovement(
-        name='redeltamultibase',
-        type=optimisation,
-        description=_('deltas within internal storage will be recalculated '
-                      'against multiple base revision and the smallest '
-                      'difference will be used; the size of the repository may '
-                      'shrink significantly when there are many merges; this '
-                      'optimization will slow down execution in proportion to '
-                      'the number of merges in the repository and the amount '
-                      'of files in the repository; this slow down should not '
-                      'be significant unless there are tens of thousands of '
-                      'files and thousands of merges'),
-        upgrademessage=_('deltas within internal storage will choose an '
-                         'optimal delta by computing deltas against multiple '
-                         'parents; may slow down execution time '
-                         'significantly')))
-
-    improvements.append(upgradeimprovement(
-        name='redeltaall',
-        type=optimisation,
-        description=_('deltas within internal storage will always be '
-                      'recalculated without reusing prior deltas; this will '
-                      'likely make execution run several times slower; this '
-                      'optimization is typically not needed'),
-        upgrademessage=_('deltas within internal storage will be fully '
-                         'recomputed; this will likely drastically slow down '
-                         'execution time')))
-
-    return improvements
-
-def upgradedetermineactions(repo, improvements, sourcereqs, destreqs,
-                            optimize):
-    """Determine upgrade actions that will be performed.
-
-    Given a list of improvements as returned by ``upgradefindimprovements``,
-    determine the list of upgrade actions that will be performed.
-
-    The role of this function is to filter improvements if needed, apply
-    recommended optimizations from the improvements list that make sense,
-    etc.
-
-    Returns a list of action names.
-    """
-    newactions = []
-
-    knownreqs = upgradesupporteddestrequirements(repo)
-
-    for i in improvements:
-        name = i.name
-
-        # If the action is a requirement that doesn't show up in the
-        # destination requirements, prune the action.
-        if name in knownreqs and name not in destreqs:
-            continue
-
-        if i.type == deficiency:
-            newactions.append(name)
-
-    newactions.extend(o for o in sorted(optimize) if o not in newactions)
-
-    # FUTURE consider adding some optimizations here for certain transitions.
-    # e.g. adding generaldelta could schedule parent redeltas.
-
-    return newactions
-
-def _revlogfrompath(repo, path):
-    """Obtain a revlog from a repo path.
-
-    An instance of the appropriate class is returned.
-    """
-    if path == '00changelog.i':
-        return changelog.changelog(repo.svfs)
-    elif path.endswith('00manifest.i'):
-        mandir = path[:-len('00manifest.i')]
-        return manifest.manifestrevlog(repo.svfs, dir=mandir)
-    else:
-        # Filelogs don't do anything special with settings. So we can use a
-        # vanilla revlog.
-        return revlog.revlog(repo.svfs, path)
-
-def _copyrevlogs(ui, srcrepo, dstrepo, tr, deltareuse, aggressivemergedeltas):
-    """Copy revlogs between 2 repos."""
-    revcount = 0
-    srcsize = 0
-    srcrawsize = 0
-    dstsize = 0
-    fcount = 0
-    frevcount = 0
-    fsrcsize = 0
-    frawsize = 0
-    fdstsize = 0
-    mcount = 0
-    mrevcount = 0
-    msrcsize = 0
-    mrawsize = 0
-    mdstsize = 0
-    crevcount = 0
-    csrcsize = 0
-    crawsize = 0
-    cdstsize = 0
-
-    # Perform a pass to collect metadata. This validates we can open all
-    # source files and allows a unified progress bar to be displayed.
-    for unencoded, encoded, size in srcrepo.store.walk():
-        if unencoded.endswith('.d'):
-            continue
-
-        rl = _revlogfrompath(srcrepo, unencoded)
-        revcount += len(rl)
-
-        datasize = 0
-        rawsize = 0
-        idx = rl.index
-        for rev in rl:
-            e = idx[rev]
-            datasize += e[1]
-            rawsize += e[2]
-
-        srcsize += datasize
-        srcrawsize += rawsize
-
-        # This is for the separate progress bars.
-        if isinstance(rl, changelog.changelog):
-            crevcount += len(rl)
-            csrcsize += datasize
-            crawsize += rawsize
-        elif isinstance(rl, manifest.manifestrevlog):
-            mcount += 1
-            mrevcount += len(rl)
-            msrcsize += datasize
-            mrawsize += rawsize
-        elif isinstance(rl, revlog.revlog):
-            fcount += 1
-            frevcount += len(rl)
-            fsrcsize += datasize
-            frawsize += rawsize
-
-    if not revcount:
-        return
-
-    ui.write(_('migrating %d total revisions (%d in filelogs, %d in manifests, '
-               '%d in changelog)\n') %
-             (revcount, frevcount, mrevcount, crevcount))
-    ui.write(_('migrating %s in store; %s tracked data\n') % (
-             (util.bytecount(srcsize), util.bytecount(srcrawsize))))
-
-    # Used to keep track of progress.
-    progress = []
-    def oncopiedrevision(rl, rev, node):
-        progress[1] += 1
-        srcrepo.ui.progress(progress[0], progress[1], total=progress[2])
-
-    # Do the actual copying.
-    # FUTURE this operation can be farmed off to worker processes.
-    seen = set()
-    for unencoded, encoded, size in srcrepo.store.walk():
-        if unencoded.endswith('.d'):
-            continue
-
-        oldrl = _revlogfrompath(srcrepo, unencoded)
-        newrl = _revlogfrompath(dstrepo, unencoded)
-
-        if isinstance(oldrl, changelog.changelog) and 'c' not in seen:
-            ui.write(_('finished migrating %d manifest revisions across %d '
-                       'manifests; change in size: %s\n') %
-                     (mrevcount, mcount, util.bytecount(mdstsize - msrcsize)))
-
-            ui.write(_('migrating changelog containing %d revisions '
-                       '(%s in store; %s tracked data)\n') %
-                     (crevcount, util.bytecount(csrcsize),
-                      util.bytecount(crawsize)))
-            seen.add('c')
-            progress[:] = [_('changelog revisions'), 0, crevcount]
-        elif isinstance(oldrl, manifest.manifestrevlog) and 'm' not in seen:
-            ui.write(_('finished migrating %d filelog revisions across %d '
-                       'filelogs; change in size: %s\n') %
-                     (frevcount, fcount, util.bytecount(fdstsize - fsrcsize)))
-
-            ui.write(_('migrating %d manifests containing %d revisions '
-                       '(%s in store; %s tracked data)\n') %
-                     (mcount, mrevcount, util.bytecount(msrcsize),
-                      util.bytecount(mrawsize)))
-            seen.add('m')
-            progress[:] = [_('manifest revisions'), 0, mrevcount]
-        elif 'f' not in seen:
-            ui.write(_('migrating %d filelogs containing %d revisions '
-                       '(%s in store; %s tracked data)\n') %
-                     (fcount, frevcount, util.bytecount(fsrcsize),
-                      util.bytecount(frawsize)))
-            seen.add('f')
-            progress[:] = [_('file revisions'), 0, frevcount]
-
-        ui.progress(progress[0], progress[1], total=progress[2])
-
-        ui.note(_('cloning %d revisions from %s\n') % (len(oldrl), unencoded))
-        oldrl.clone(tr, newrl, addrevisioncb=oncopiedrevision,
-                    deltareuse=deltareuse,
-                    aggressivemergedeltas=aggressivemergedeltas)
-
-        datasize = 0
-        idx = newrl.index
-        for rev in newrl:
-            datasize += idx[rev][1]
-
-        dstsize += datasize
-
-        if isinstance(newrl, changelog.changelog):
-            cdstsize += datasize
-        elif isinstance(newrl, manifest.manifestrevlog):
-            mdstsize += datasize
-        else:
-            fdstsize += datasize
-
-    ui.progress(progress[0], None)
-
-    ui.write(_('finished migrating %d changelog revisions; change in size: '
-               '%s\n') % (crevcount, util.bytecount(cdstsize - csrcsize)))
-
-    ui.write(_('finished migrating %d total revisions; total change in store '
-               'size: %s\n') % (revcount, util.bytecount(dstsize - srcsize)))
-
-def _upgradefilterstorefile(srcrepo, dstrepo, requirements, path, mode, st):
-    """Determine whether to copy a store file during upgrade.
-
-    This function is called when migrating store files from ``srcrepo`` to
-    ``dstrepo`` as part of upgrading a repository.
-
-    Args:
-      srcrepo: repo we are copying from
-      dstrepo: repo we are copying to
-      requirements: set of requirements for ``dstrepo``
-      path: store file being examined
-      mode: the ``ST_MODE`` file type of ``path``
-      st: ``stat`` data structure for ``path``
-
-    Function should return ``True`` if the file is to be copied.
-    """
-    # Skip revlogs.
-    if path.endswith(('.i', '.d')):
-        return False
-    # Skip transaction related files.
-    if path.startswith('undo'):
-        return False
-    # Only copy regular files.
-    if mode != stat.S_IFREG:
-        return False
-    # Skip other skipped files.
-    if path in ('lock', 'fncache'):
-        return False
-
-    return True
-
-def _upgradefinishdatamigration(ui, srcrepo, dstrepo, requirements):
-    """Hook point for extensions to perform additional actions during upgrade.
-
-    This function is called after revlogs and store files have been copied but
-    before the new store is swapped into the original location.
-    """
-
-def _upgraderepo(ui, srcrepo, dstrepo, requirements, actions):
-    """Do the low-level work of upgrading a repository.
-
-    The upgrade is effectively performed as a copy between a source
-    repository and a temporary destination repository.
-
-    The source repository is unmodified for as long as possible so the
-    upgrade can abort at any time without causing loss of service for
-    readers and without corrupting the source repository.
-    """
-    assert srcrepo.currentwlock()
-    assert dstrepo.currentwlock()
-
-    ui.write(_('(it is safe to interrupt this process any time before '
-               'data migration completes)\n'))
-
-    if 'redeltaall' in actions:
-        deltareuse = revlog.revlog.DELTAREUSENEVER
-    elif 'redeltaparent' in actions:
-        deltareuse = revlog.revlog.DELTAREUSESAMEREVS
-    elif 'redeltamultibase' in actions:
-        deltareuse = revlog.revlog.DELTAREUSESAMEREVS
-    else:
-        deltareuse = revlog.revlog.DELTAREUSEALWAYS
-
-    with dstrepo.transaction('upgrade') as tr:
-        _copyrevlogs(ui, srcrepo, dstrepo, tr, deltareuse,
-                     'redeltamultibase' in actions)
-
-    # Now copy other files in the store directory.
-    for p, kind, st in srcrepo.store.vfs.readdir('', stat=True):
-        if not _upgradefilterstorefile(srcrepo, dstrepo, requirements,
-                                       p, kind, st):
-            continue
-
-        srcrepo.ui.write(_('copying %s\n') % p)
-        src = srcrepo.store.vfs.join(p)
-        dst = dstrepo.store.vfs.join(p)
-        util.copyfile(src, dst, copystat=True)
-
-    _upgradefinishdatamigration(ui, srcrepo, dstrepo, requirements)
-
-    ui.write(_('data fully migrated to temporary repository\n'))
-
-    backuppath = tempfile.mkdtemp(prefix='upgradebackup.', dir=srcrepo.path)
-    backupvfs = vfsmod.vfs(backuppath)
-
-    # Make a backup of requires file first, as it is the first to be modified.
-    util.copyfile(srcrepo.vfs.join('requires'), backupvfs.join('requires'))
-
-    # We install an arbitrary requirement that clients must not support
-    # as a mechanism to lock out new clients during the data swap. This is
-    # better than allowing a client to continue while the repository is in
-    # an inconsistent state.
-    ui.write(_('marking source repository as being upgraded; clients will be '
-               'unable to read from repository\n'))
-    scmutil.writerequires(srcrepo.vfs,
-                          srcrepo.requirements | set(['upgradeinprogress']))
-
-    ui.write(_('starting in-place swap of repository data\n'))
-    ui.write(_('replaced files will be backed up at %s\n') %
-             backuppath)
-
-    # Now swap in the new store directory. Doing it as a rename should make
-    # the operation nearly instantaneous and atomic (at least in well-behaved
-    # environments).
-    ui.write(_('replacing store...\n'))
-    tstart = util.timer()
-    util.rename(srcrepo.spath, backupvfs.join('store'))
-    util.rename(dstrepo.spath, srcrepo.spath)
-    elapsed = util.timer() - tstart
-    ui.write(_('store replacement complete; repository was inconsistent for '
-               '%0.1fs\n') % elapsed)
-
-    # We first write the requirements file. Any new requirements will lock
-    # out legacy clients.
-    ui.write(_('finalizing requirements file and making repository readable '
-               'again\n'))
-    scmutil.writerequires(srcrepo.vfs, requirements)
-
-    # The lock file from the old store won't be removed because nothing has a
-    # reference to its new location. So clean it up manually. Alternatively, we
-    # could update srcrepo.svfs and other variables to point to the new
-    # location. This is simpler.
-    backupvfs.unlink('store/lock')
-
-    return backuppath
-
-def upgraderepo(ui, repo, run=False, optimize=None):
-    """Upgrade a repository in place."""
-    # Avoid cycle: cmdutil -> repair -> localrepo -> cmdutil
-    from . import localrepo
-
-    optimize = set(optimize or [])
-    repo = repo.unfiltered()
-
-    # Ensure the repository can be upgraded.
-    missingreqs = upgraderequiredsourcerequirements(repo) - repo.requirements
-    if missingreqs:
-        raise error.Abort(_('cannot upgrade repository; requirement '
-                            'missing: %s') % _(', ').join(sorted(missingreqs)))
-
-    blockedreqs = upgradeblocksourcerequirements(repo) & repo.requirements
-    if blockedreqs:
-        raise error.Abort(_('cannot upgrade repository; unsupported source '
-                            'requirement: %s') %
-                          _(', ').join(sorted(blockedreqs)))
-
-    # FUTURE there is potentially a need to control the wanted requirements via
-    # command arguments or via an extension hook point.
-    newreqs = localrepo.newreporequirements(repo)
-
-    noremovereqs = (repo.requirements - newreqs -
-                   upgradesupportremovedrequirements(repo))
-    if noremovereqs:
-        raise error.Abort(_('cannot upgrade repository; requirement would be '
-                            'removed: %s') % _(', ').join(sorted(noremovereqs)))
-
-    noaddreqs = (newreqs - repo.requirements -
-                 upgradeallowednewrequirements(repo))
-    if noaddreqs:
-        raise error.Abort(_('cannot upgrade repository; do not support adding '
-                            'requirement: %s') %
-                          _(', ').join(sorted(noaddreqs)))
-
-    unsupportedreqs = newreqs - upgradesupporteddestrequirements(repo)
-    if unsupportedreqs:
-        raise error.Abort(_('cannot upgrade repository; do not support '
-                            'destination requirement: %s') %
-                          _(', ').join(sorted(unsupportedreqs)))
-
-    # Find and validate all improvements that can be made.
-    improvements = upgradefindimprovements(repo)
-    for i in improvements:
-        if i.type not in (deficiency, optimisation):
-            raise error.Abort(_('unexpected improvement type %s for %s') % (
-                i.type, i.name))
-
-    # Validate arguments.
-    unknownoptimize = optimize - set(i.name for i in improvements
-                                     if i.type == optimisation)
-    if unknownoptimize:
-        raise error.Abort(_('unknown optimization action requested: %s') %
-                          ', '.join(sorted(unknownoptimize)),
-                          hint=_('run without arguments to see valid '
-                                 'optimizations'))
-
-    actions = upgradedetermineactions(repo, improvements, repo.requirements,
-                                      newreqs, optimize)
-
-    def printrequirements():
-        ui.write(_('requirements\n'))
-        ui.write(_('   preserved: %s\n') %
-                 _(', ').join(sorted(newreqs & repo.requirements)))
-
-        if repo.requirements - newreqs:
-            ui.write(_('   removed: %s\n') %
-                     _(', ').join(sorted(repo.requirements - newreqs)))
-
-        if newreqs - repo.requirements:
-            ui.write(_('   added: %s\n') %
-                     _(', ').join(sorted(newreqs - repo.requirements)))
-
-        ui.write('\n')
-
-    def printupgradeactions():
-        for action in actions:
-            for i in improvements:
-                if i.name == action:
-                    ui.write('%s\n   %s\n\n' %
-                             (i.name, i.upgrademessage))
-
-    if not run:
-        fromdefault = []
-        fromconfig = []
-        optimizations = []
-
-        for i in improvements:
-            assert i.type in (deficiency, optimisation)
-            if i.type == deficiency:
-                if i.fromdefault:
-                    fromdefault.append(i)
-                if i.fromconfig:
-                    fromconfig.append(i)
-            else:
-                optimizations.append(i)
-
-        if fromdefault or fromconfig:
-            fromconfignames = set(x.name for x in fromconfig)
-            onlydefault = [i for i in fromdefault
-                           if i.name not in fromconfignames]
-
-            if fromconfig:
-                ui.write(_('repository lacks features recommended by '
-                           'current config options:\n\n'))
-                for i in fromconfig:
-                    ui.write('%s\n   %s\n\n' % (i.name, i.description))
-
-            if onlydefault:
-                ui.write(_('repository lacks features used by the default '
-                           'config options:\n\n'))
-                for i in onlydefault:
-                    ui.write('%s\n   %s\n\n' % (i.name, i.description))
-
-            ui.write('\n')
-        else:
-            ui.write(_('(no feature deficiencies found in existing '
-                       'repository)\n'))
-
-        ui.write(_('performing an upgrade with "--run" will make the following '
-                   'changes:\n\n'))
-
-        printrequirements()
-        printupgradeactions()
-
-        unusedoptimize = [i for i in improvements
-                          if i.name not in actions and i.type == optimisation]
-        if unusedoptimize:
-            ui.write(_('additional optimizations are available by specifying '
-                     '"--optimize <name>":\n\n'))
-            for i in unusedoptimize:
-                ui.write(_('%s\n   %s\n\n') % (i.name, i.description))
-        return
-
-    # Else we're in the run=true case.
-    ui.write(_('upgrade will perform the following actions:\n\n'))
-    printrequirements()
-    printupgradeactions()
-
-    ui.write(_('beginning upgrade...\n'))
-    with repo.wlock():
-        with repo.lock():
-            ui.write(_('repository locked and read-only\n'))
-            # Our strategy for upgrading the repository is to create a new,
-            # temporary repository, write data to it, then do a swap of the
-            # data. There are less heavyweight ways to do this, but it is easier
-            # to create a new repo object than to instantiate all the components
-            # (like the store) separately.
-            tmppath = tempfile.mkdtemp(prefix='upgrade.', dir=repo.path)
-            backuppath = None
-            try:
-                ui.write(_('creating temporary repository to stage migrated '
-                           'data: %s\n') % tmppath)
-                dstrepo = localrepo.localrepository(repo.baseui,
-                                                    path=tmppath,
-                                                    create=True)
-
-                with dstrepo.wlock():
-                    with dstrepo.lock():
-                        backuppath = _upgraderepo(ui, repo, dstrepo, newreqs,
-                                                  actions)
-
-            finally:
-                ui.write(_('removing temporary repository %s\n') % tmppath)
-                repo.vfs.rmtree(tmppath, forcibly=True)
-
-                if backuppath:
-                    ui.warn(_('copy of old repository backed up at %s\n') %
-                            backuppath)
-                    ui.warn(_('the old repository will not be deleted; remove '
-                              'it to free up disk space once the upgraded '
-                              'repository is verified\n'))

mercurial/upgrade.py

@@ -1,1096 +1,758
 # 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
-import hashlib
 import stat
 import tempfile
 
 from .i18n import _
-from .node import short
 from . import (
-    bundle2,
-    changegroup,
     changelog,
     error,
-    exchange,
     manifest,
-    obsolete,
     revlog,
     scmutil,
     util,
     vfs as vfsmod,
 )
 
-def _bundle(repo, bases, heads, node, suffix, compress=True):
-    """create a bundle with the specified revisions as a backup"""
-    cgversion = changegroup.safeversion(repo)
-
-    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 = hashlib.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 bundle2.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.manifestlog._revlog)
-    for fname in files:
-        collectone(repo.file(fname))
-
-    return s
-
-def strip(ui, repo, nodelist, backup=True, topic='backup'):
-    # This function operates within a transaction of its own, but does
-    # not take any lock on the repo.
-    # 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)
-
-    files = _collectfiles(repo, striprev)
-    saverevs = _collectbrokencsets(repo, files, striprev)
-
-    # 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)
-    saveheads = set(saverevs)
-    for r in cl.revs(start=striprev + 1):
-        if any(p in tostrip for p in cl.parentrevs(r)):
-            tostrip.add(r)
-
-        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))
-    tmpbundlefile = None
-    if saveheads:
-        # do not compress temporary bundle if we remove it from disk later
-        tmpbundlefile = _bundle(repo, savebases, saveheads, node, 'temp',
-                            compress=False)
-
-    mfst = repo.manifestlog._revlog
-
-    curtr = repo.currenttransaction()
-    if curtr is not None:
-        del curtr  # avoid carrying reference to transaction for nothing
-        raise error.ProgrammingError('cannot strip from inside a transaction')
-
-    try:
-        with repo.transaction("strip") as tr:
-            offset = len(tr.entries)
-
-            tr.startgroup()
-            cl.strip(striprev, tr)
-            mfst.strip(striprev, tr)
-            if 'treemanifest' in repo.requirements: # safe but unnecessary
-                                                    # otherwise
-                for unencoded, encoded, size in repo.store.datafiles():
-                    if (unencoded.startswith('meta/') and
-                        unencoded.endswith('00manifest.i')):
-                        dir = unencoded[5:-12]
-                        repo.manifestlog._revlog.dirlog(dir).strip(striprev, tr)
-            for fn in files:
-                repo.file(fn).strip(striprev, tr)
-            tr.endgroup()
-
-            for i in xrange(offset, len(tr.entries)):
-                file, troffset, ignore = tr.entries[i]
-                with repo.svfs(file, 'a', checkambig=True) as fp:
-                    fp.truncate(troffset)
-                if troffset == 0:
-                    repo.store.markremoved(file)
-
-        if tmpbundlefile:
-            ui.note(_("adding branch\n"))
-            f = vfs.open(tmpbundlefile, "rb")
-            gen = exchange.readbundle(ui, f, tmpbundlefile, vfs)
-            if not repo.ui.verbose:
-                # silence internal shuffling chatter
-                repo.ui.pushbuffer()
-            if isinstance(gen, bundle2.unbundle20):
-                with repo.transaction('strip') as tr:
-                    tr.hookargs = {'source': 'strip',
-                                   'url': 'bundle:' + vfs.join(tmpbundlefile)}
-                    bundle2.applybundle(repo, gen, tr, source='strip',
-                                        url='bundle:' + vfs.join(tmpbundlefile))
-            else:
-                gen.apply(repo, 'strip', 'bundle:' + vfs.join(tmpbundlefile),
-                          True)
-            if not repo.ui.verbose:
-                repo.ui.popbuffer()
-            f.close()
-        repo._phasecache.invalidate()
-
-        for m in updatebm:
-            bm[m] = repo[newbmtarget].node()
-
-        with repo.lock():
-            with repo.transaction('repair') as tr:
-                bm.recordchange(tr)
-
-        # 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)))
-
-    except: # re-raises
-        if backupfile:
-            ui.warn(_("strip failed, backup bundle stored in '%s'\n")
-                    % vfs.join(backupfile))
-        if tmpbundlefile:
-            ui.warn(_("strip failed, unrecovered changes stored in '%s'\n")
-                    % vfs.join(tmpbundlefile))
-            ui.warn(_("(fix the problem, then recover the changesets with "
-                      "\"hg unbundle '%s'\")\n") % vfs.join(tmpbundlefile))
-        raise
-    else:
-        if tmpbundlefile:
-            # Remove temporary bundle only if there were no exceptions
-            vfs.unlink(tmpbundlefile)
-
-    repo.destroyed()
-    # return the backup file path (or None if 'backup' was False) so
-    # extensions can use it
-    return backupfile
-
-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
-
-    with repo.lock():
-        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(_('rebuilding'), rev, total=repolen,
-                        unit=_('changesets'))
-
-            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(_('rebuilding'), None)
-
-        if 'treemanifest' in repo.requirements: # safe but unnecessary otherwise
-            for dir in util.dirs(seenfiles):
-                i = 'meta/%s/00manifest.i' % dir
-                d = 'meta/%s/00manifest.d' % dir
-
-                if repo.store._exists(i):
-                    newentries.add(i)
-                if repo.store._exists(d):
-                    newentries.add(d)
-
-        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
-
-            with repo.transaction('fncache') as tr:
-                fnc.write(tr)
-        else:
-            ui.write(_('fncache already up to date\n'))
-
-def stripbmrevset(repo, mark):
-    """
-    The revset to strip when strip is called with -B mark
-
-    Needs to live here so extensions can use it and wrap it even when strip is
-    not enabled or not present on a box.
-    """
-    return repo.revs("ancestors(bookmark(%s)) - "
-                     "ancestors(head() and not bookmark(%s)) - "
-                     "ancestors(bookmark() and not bookmark(%s))",
-                     mark, mark, mark)
-
-def deleteobsmarkers(obsstore, indices):
-    """Delete some obsmarkers from obsstore and return how many were deleted
-
-    'indices' is a list of ints which are the indices
-    of the markers to be deleted.
-
-    Every invocation of this function completely rewrites the obsstore file,
-    skipping the markers we want to be removed. The new temporary file is
-    created, remaining markers are written there and on .close() this file
-    gets atomically renamed to obsstore, thus guaranteeing consistency."""
-    if not indices:
-        # we don't want to rewrite the obsstore with the same content
-        return
-
-    left = []
-    current = obsstore._all
-    n = 0
-    for i, m in enumerate(current):
-        if i in indices:
-            n += 1
-            continue
-        left.append(m)
-
-    newobsstorefile = obsstore.svfs('obsstore', 'w', atomictemp=True)
-    for bytes in obsolete.encodemarkers(left, True, obsstore._version):
-        newobsstorefile.write(bytes)
-    newobsstorefile.close()
-    return n
-
 def upgraderequiredsourcerequirements(repo):
     """Obtain requirements required to be present to upgrade a repo.
 
     An upgrade will not be allowed if the repository doesn't have the
     requirements returned by this function.
     """
     return set([
         # Introduced in Mercurial 0.9.2.
         'revlogv1',
         # Introduced in Mercurial 0.9.2.
         'store',
     ])
 
 def upgradeblocksourcerequirements(repo):
     """Obtain requirements that will prevent an upgrade from occurring.
 
     An upgrade cannot be performed if the source repository contains a
     requirements in the returned set.
     """
     return set([
         # The upgrade code does not yet support these experimental features.
         # This is an artificial limitation.
         'manifestv2',
         'treemanifest',
         # This was a precursor to generaldelta and was never enabled by default.
         # It should (hopefully) not exist in the wild.
         'parentdelta',
         # Upgrade should operate on the actual store, not the shared link.
         'shared',
     ])
 
 def upgradesupportremovedrequirements(repo):
     """Obtain requirements that can be removed during an upgrade.
 
     If an upgrade were to create a repository that dropped a requirement,
     the dropped requirement must appear in the returned set for the upgrade
     to be allowed.
     """
     return set()
 
 def upgradesupporteddestrequirements(repo):
     """Obtain requirements that upgrade supports in the destination.
 
     If the result of the upgrade would create requirements not in this set,
     the upgrade is disallowed.
 
     Extensions should monkeypatch this to add their custom requirements.
     """
     return set([
         'dotencode',
         'fncache',
         'generaldelta',
         'revlogv1',
         'store',
     ])
 
 def upgradeallowednewrequirements(repo):
     """Obtain requirements that can be added to a repository during upgrade.
 
     This is used to disallow proposed requirements from being added when
     they weren't present before.
 
     We use a list of allowed requirement additions instead of a list of known
     bad additions because the whitelist approach is safer and will prevent
     future, unknown requirements from accidentally being added.
     """
     return set([
         'dotencode',
         'fncache',
         'generaldelta',
     ])
 
 deficiency = 'deficiency'
 optimisation = 'optimization'
 
 class upgradeimprovement(object):
     """Represents an improvement that can be made as part of an upgrade.
 
     The following attributes are defined on each instance:
 
     name
        Machine-readable string uniquely identifying this improvement. It
        will be mapped to an action later in the upgrade process.
 
     type
        Either ``deficiency`` or ``optimisation``. A deficiency is an obvious
        problem. An optimization is an action (sometimes optional) that
        can be taken to further improve the state of the repository.
 
     description
        Message intended for humans explaining the improvement in more detail,
        including the implications of it. For ``deficiency`` types, should be
        worded in the present tense. For ``optimisation`` types, should be
        worded in the future tense.
 
     upgrademessage
        Message intended for humans explaining what an upgrade addressing this
        issue will do. Should be worded in the future tense.
 
     fromdefault (``deficiency`` types only)
        Boolean indicating whether the current (deficient) state deviates
        from Mercurial's default configuration.
 
     fromconfig (``deficiency`` types only)
        Boolean indicating whether the current (deficient) state deviates
        from the current Mercurial configuration.
     """
     def __init__(self, name, type, description, upgrademessage, **kwargs):
         self.name = name
         self.type = type
         self.description = description
         self.upgrademessage = upgrademessage
 
         for k, v in kwargs.items():
             setattr(self, k, v)
 
 def upgradefindimprovements(repo):
     """Determine improvements that can be made to the repo during upgrade.
 
     Returns a list of ``upgradeimprovement`` describing repository deficiencies
     and optimizations.
     """
     # Avoid cycle: cmdutil -> repair -> localrepo -> cmdutil
     from . import localrepo
 
     newreporeqs = localrepo.newreporequirements(repo)
 
     improvements = []
 
     # We could detect lack of revlogv1 and store here, but they were added
     # in 0.9.2 and we don't support upgrading repos without these
     # requirements, so let's not bother.
 
     if 'fncache' not in repo.requirements:
         improvements.append(upgradeimprovement(
             name='fncache',
             type=deficiency,
             description=_('long and reserved filenames may not work correctly; '
                           'repository performance is sub-optimal'),
             upgrademessage=_('repository will be more resilient to storing '
                              'certain paths and performance of certain '
                              'operations should be improved'),
             fromdefault=True,
             fromconfig='fncache' in newreporeqs))
 
     if 'dotencode' not in repo.requirements:
         improvements.append(upgradeimprovement(
             name='dotencode',
             type=deficiency,
             description=_('storage of filenames beginning with a period or '
                           'space may not work correctly'),
             upgrademessage=_('repository will be better able to store files '
                              'beginning with a space or period'),
             fromdefault=True,
             fromconfig='dotencode' in newreporeqs))
 
     if 'generaldelta' not in repo.requirements:
         improvements.append(upgradeimprovement(
             name='generaldelta',
             type=deficiency,
             description=_('deltas within internal storage are unable to '
                           'choose optimal revisions; repository is larger and '
                           'slower than it could be; interaction with other '
                           'repositories may require extra network and CPU '
                           'resources, making "hg push" and "hg pull" slower'),
             upgrademessage=_('repository storage will be able to create '
                              'optimal deltas; new repository data will be '
                              'smaller and read times should decrease; '
                              'interacting with other repositories using this '
                              'storage model should require less network and '
                              'CPU resources, making "hg push" and "hg pull" '
                              'faster'),
             fromdefault=True,
             fromconfig='generaldelta' in newreporeqs))
 
     # Mercurial 4.0 changed changelogs to not use delta chains. Search for
     # changelogs with deltas.
     cl = repo.changelog
     for rev in cl:
         chainbase = cl.chainbase(rev)
         if chainbase != rev:
             improvements.append(upgradeimprovement(
                 name='removecldeltachain',
                 type=deficiency,
                 description=_('changelog storage is using deltas instead of '
                               'raw entries; changelog reading and any '
                               'operation relying on changelog data are slower '
                               'than they could be'),
                 upgrademessage=_('changelog storage will be reformated to '
                                  'store raw entries; changelog reading will be '
                                  'faster; changelog size may be reduced'),
                 fromdefault=True,
                 fromconfig=True))
             break
 
     # Now for the optimizations.
 
     # These are unconditionally added. There is logic later that figures out
     # which ones to apply.
 
     improvements.append(upgradeimprovement(
         name='redeltaparent',
         type=optimisation,
         description=_('deltas within internal storage will be recalculated to '
                       'choose an optimal base revision where this was not '
                       'already done; the size of the repository may shrink and '
                       'various operations may become faster; the first time '
                       'this optimization is performed could slow down upgrade '
                       'execution considerably; subsequent invocations should '
                       'not run noticeably slower'),
         upgrademessage=_('deltas within internal storage will choose a new '
                          'base revision if needed')))
 
     improvements.append(upgradeimprovement(
         name='redeltamultibase',
         type=optimisation,
         description=_('deltas within internal storage will be recalculated '
                       'against multiple base revision and the smallest '
                       'difference will be used; the size of the repository may '
                       'shrink significantly when there are many merges; this '
                       'optimization will slow down execution in proportion to '
                       'the number of merges in the repository and the amount '
                       'of files in the repository; this slow down should not '
                       'be significant unless there are tens of thousands of '
                       'files and thousands of merges'),
         upgrademessage=_('deltas within internal storage will choose an '
                          'optimal delta by computing deltas against multiple '
                          'parents; may slow down execution time '
                          'significantly')))
 
     improvements.append(upgradeimprovement(
         name='redeltaall',
         type=optimisation,
         description=_('deltas within internal storage will always be '
                       'recalculated without reusing prior deltas; this will '
                       'likely make execution run several times slower; this '
                       'optimization is typically not needed'),
         upgrademessage=_('deltas within internal storage will be fully '
                          'recomputed; this will likely drastically slow down '
                          'execution time')))
 
     return improvements
 
 def upgradedetermineactions(repo, improvements, sourcereqs, destreqs,
                             optimize):
     """Determine upgrade actions that will be performed.
 
     Given a list of improvements as returned by ``upgradefindimprovements``,
     determine the list of upgrade actions that will be performed.
 
     The role of this function is to filter improvements if needed, apply
     recommended optimizations from the improvements list that make sense,
     etc.
 
     Returns a list of action names.
     """
     newactions = []
 
     knownreqs = upgradesupporteddestrequirements(repo)
 
     for i in improvements:
         name = i.name
 
         # If the action is a requirement that doesn't show up in the
         # destination requirements, prune the action.
         if name in knownreqs and name not in destreqs:
             continue
 
         if i.type == deficiency:
             newactions.append(name)
 
     newactions.extend(o for o in sorted(optimize) if o not in newactions)
 
     # FUTURE consider adding some optimizations here for certain transitions.
     # e.g. adding generaldelta could schedule parent redeltas.
 
     return newactions
 
 def _revlogfrompath(repo, path):
     """Obtain a revlog from a repo path.
 
     An instance of the appropriate class is returned.
     """
     if path == '00changelog.i':
         return changelog.changelog(repo.svfs)
     elif path.endswith('00manifest.i'):
         mandir = path[:-len('00manifest.i')]
         return manifest.manifestrevlog(repo.svfs, dir=mandir)
     else:
         # Filelogs don't do anything special with settings. So we can use a
         # vanilla revlog.
         return revlog.revlog(repo.svfs, path)
 
 def _copyrevlogs(ui, srcrepo, dstrepo, tr, deltareuse, aggressivemergedeltas):
     """Copy revlogs between 2 repos."""
     revcount = 0
     srcsize = 0
     srcrawsize = 0
     dstsize = 0
     fcount = 0
     frevcount = 0
     fsrcsize = 0
     frawsize = 0
     fdstsize = 0
     mcount = 0
     mrevcount = 0
     msrcsize = 0
     mrawsize = 0
     mdstsize = 0
     crevcount = 0
     csrcsize = 0
     crawsize = 0
     cdstsize = 0
 
     # Perform a pass to collect metadata. This validates we can open all
     # source files and allows a unified progress bar to be displayed.
     for unencoded, encoded, size in srcrepo.store.walk():
         if unencoded.endswith('.d'):
             continue
 
         rl = _revlogfrompath(srcrepo, unencoded)
         revcount += len(rl)
 
         datasize = 0
         rawsize = 0
         idx = rl.index
         for rev in rl:
             e = idx[rev]
             datasize += e[1]
             rawsize += e[2]
 
         srcsize += datasize
         srcrawsize += rawsize
 
         # This is for the separate progress bars.
         if isinstance(rl, changelog.changelog):
             crevcount += len(rl)
             csrcsize += datasize
             crawsize += rawsize
         elif isinstance(rl, manifest.manifestrevlog):
             mcount += 1
             mrevcount += len(rl)
             msrcsize += datasize
             mrawsize += rawsize
         elif isinstance(rl, revlog.revlog):
             fcount += 1
             frevcount += len(rl)
             fsrcsize += datasize
             frawsize += rawsize
 
     if not revcount:
         return
 
     ui.write(_('migrating %d total revisions (%d in filelogs, %d in manifests, '
                '%d in changelog)\n') %
              (revcount, frevcount, mrevcount, crevcount))
     ui.write(_('migrating %s in store; %s tracked data\n') % (
              (util.bytecount(srcsize), util.bytecount(srcrawsize))))
 
     # Used to keep track of progress.
     progress = []
     def oncopiedrevision(rl, rev, node):
         progress[1] += 1
         srcrepo.ui.progress(progress[0], progress[1], total=progress[2])
 
     # Do the actual copying.
     # FUTURE this operation can be farmed off to worker processes.
     seen = set()
     for unencoded, encoded, size in srcrepo.store.walk():
         if unencoded.endswith('.d'):
             continue
 
         oldrl = _revlogfrompath(srcrepo, unencoded)
         newrl = _revlogfrompath(dstrepo, unencoded)
 
         if isinstance(oldrl, changelog.changelog) and 'c' not in seen:
             ui.write(_('finished migrating %d manifest revisions across %d '
                        'manifests; change in size: %s\n') %
                      (mrevcount, mcount, util.bytecount(mdstsize - msrcsize)))
 
             ui.write(_('migrating changelog containing %d revisions '
                        '(%s in store; %s tracked data)\n') %
                      (crevcount, util.bytecount(csrcsize),
                       util.bytecount(crawsize)))
             seen.add('c')
             progress[:] = [_('changelog revisions'), 0, crevcount]
         elif isinstance(oldrl, manifest.manifestrevlog) and 'm' not in seen:
             ui.write(_('finished migrating %d filelog revisions across %d '
                        'filelogs; change in size: %s\n') %
                      (frevcount, fcount, util.bytecount(fdstsize - fsrcsize)))
 
             ui.write(_('migrating %d manifests containing %d revisions '
                        '(%s in store; %s tracked data)\n') %
                      (mcount, mrevcount, util.bytecount(msrcsize),
                       util.bytecount(mrawsize)))
             seen.add('m')
             progress[:] = [_('manifest revisions'), 0, mrevcount]
         elif 'f' not in seen:
             ui.write(_('migrating %d filelogs containing %d revisions '
                        '(%s in store; %s tracked data)\n') %
                      (fcount, frevcount, util.bytecount(fsrcsize),
                       util.bytecount(frawsize)))
             seen.add('f')
             progress[:] = [_('file revisions'), 0, frevcount]
 
         ui.progress(progress[0], progress[1], total=progress[2])
 
         ui.note(_('cloning %d revisions from %s\n') % (len(oldrl), unencoded))
         oldrl.clone(tr, newrl, addrevisioncb=oncopiedrevision,
                     deltareuse=deltareuse,
                     aggressivemergedeltas=aggressivemergedeltas)
 
         datasize = 0
         idx = newrl.index
         for rev in newrl:
             datasize += idx[rev][1]
 
         dstsize += datasize
 
         if isinstance(newrl, changelog.changelog):
             cdstsize += datasize
         elif isinstance(newrl, manifest.manifestrevlog):
             mdstsize += datasize
         else:
             fdstsize += datasize
 
     ui.progress(progress[0], None)
 
     ui.write(_('finished migrating %d changelog revisions; change in size: '
                '%s\n') % (crevcount, util.bytecount(cdstsize - csrcsize)))
 
     ui.write(_('finished migrating %d total revisions; total change in store '
                'size: %s\n') % (revcount, util.bytecount(dstsize - srcsize)))
 
 def _upgradefilterstorefile(srcrepo, dstrepo, requirements, path, mode, st):
     """Determine whether to copy a store file during upgrade.
 
     This function is called when migrating store files from ``srcrepo`` to
     ``dstrepo`` as part of upgrading a repository.
 
     Args:
       srcrepo: repo we are copying from
       dstrepo: repo we are copying to
       requirements: set of requirements for ``dstrepo``
       path: store file being examined
       mode: the ``ST_MODE`` file type of ``path``
       st: ``stat`` data structure for ``path``
 
     Function should return ``True`` if the file is to be copied.
     """
     # Skip revlogs.
     if path.endswith(('.i', '.d')):
         return False
     # Skip transaction related files.
     if path.startswith('undo'):
         return False
     # Only copy regular files.
     if mode != stat.S_IFREG:
         return False
     # Skip other skipped files.
     if path in ('lock', 'fncache'):
         return False
 
     return True
 
 def _upgradefinishdatamigration(ui, srcrepo, dstrepo, requirements):
     """Hook point for extensions to perform additional actions during upgrade.
 
     This function is called after revlogs and store files have been copied but
     before the new store is swapped into the original location.
     """
 
 def _upgraderepo(ui, srcrepo, dstrepo, requirements, actions):
     """Do the low-level work of upgrading a repository.
 
     The upgrade is effectively performed as a copy between a source
     repository and a temporary destination repository.
 
     The source repository is unmodified for as long as possible so the
     upgrade can abort at any time without causing loss of service for
     readers and without corrupting the source repository.
     """
     assert srcrepo.currentwlock()
     assert dstrepo.currentwlock()
 
     ui.write(_('(it is safe to interrupt this process any time before '
                'data migration completes)\n'))
 
     if 'redeltaall' in actions:
         deltareuse = revlog.revlog.DELTAREUSENEVER
     elif 'redeltaparent' in actions:
         deltareuse = revlog.revlog.DELTAREUSESAMEREVS
     elif 'redeltamultibase' in actions:
         deltareuse = revlog.revlog.DELTAREUSESAMEREVS
     else:
         deltareuse = revlog.revlog.DELTAREUSEALWAYS
 
     with dstrepo.transaction('upgrade') as tr:
         _copyrevlogs(ui, srcrepo, dstrepo, tr, deltareuse,
                      'redeltamultibase' in actions)
 
     # Now copy other files in the store directory.
     for p, kind, st in srcrepo.store.vfs.readdir('', stat=True):
         if not _upgradefilterstorefile(srcrepo, dstrepo, requirements,
                                        p, kind, st):
             continue
 
         srcrepo.ui.write(_('copying %s\n') % p)
         src = srcrepo.store.vfs.join(p)
         dst = dstrepo.store.vfs.join(p)
         util.copyfile(src, dst, copystat=True)
 
     _upgradefinishdatamigration(ui, srcrepo, dstrepo, requirements)
 
     ui.write(_('data fully migrated to temporary repository\n'))
 
     backuppath = tempfile.mkdtemp(prefix='upgradebackup.', dir=srcrepo.path)
     backupvfs = vfsmod.vfs(backuppath)
 
     # Make a backup of requires file first, as it is the first to be modified.
     util.copyfile(srcrepo.vfs.join('requires'), backupvfs.join('requires'))
 
     # We install an arbitrary requirement that clients must not support
     # as a mechanism to lock out new clients during the data swap. This is
     # better than allowing a client to continue while the repository is in
     # an inconsistent state.
     ui.write(_('marking source repository as being upgraded; clients will be '
                'unable to read from repository\n'))
     scmutil.writerequires(srcrepo.vfs,
                           srcrepo.requirements | set(['upgradeinprogress']))
 
     ui.write(_('starting in-place swap of repository data\n'))
     ui.write(_('replaced files will be backed up at %s\n') %
              backuppath)
 
     # Now swap in the new store directory. Doing it as a rename should make
     # the operation nearly instantaneous and atomic (at least in well-behaved
     # environments).
     ui.write(_('replacing store...\n'))
     tstart = util.timer()
     util.rename(srcrepo.spath, backupvfs.join('store'))
     util.rename(dstrepo.spath, srcrepo.spath)
     elapsed = util.timer() - tstart
     ui.write(_('store replacement complete; repository was inconsistent for '
                '%0.1fs\n') % elapsed)
 
     # We first write the requirements file. Any new requirements will lock
     # out legacy clients.
     ui.write(_('finalizing requirements file and making repository readable '
                'again\n'))
     scmutil.writerequires(srcrepo.vfs, requirements)
 
     # The lock file from the old store won't be removed because nothing has a
     # reference to its new location. So clean it up manually. Alternatively, we
     # could update srcrepo.svfs and other variables to point to the new
     # location. This is simpler.
     backupvfs.unlink('store/lock')
 
     return backuppath
 
 def upgraderepo(ui, repo, run=False, optimize=None):
     """Upgrade a repository in place."""
     # Avoid cycle: cmdutil -> repair -> localrepo -> cmdutil
     from . import localrepo
 
     optimize = set(optimize or [])
     repo = repo.unfiltered()
 
     # Ensure the repository can be upgraded.
     missingreqs = upgraderequiredsourcerequirements(repo) - repo.requirements
     if missingreqs:
         raise error.Abort(_('cannot upgrade repository; requirement '
                             'missing: %s') % _(', ').join(sorted(missingreqs)))
 
     blockedreqs = upgradeblocksourcerequirements(repo) & repo.requirements
     if blockedreqs:
         raise error.Abort(_('cannot upgrade repository; unsupported source '
                             'requirement: %s') %
                           _(', ').join(sorted(blockedreqs)))
 
     # FUTURE there is potentially a need to control the wanted requirements via
     # command arguments or via an extension hook point.
     newreqs = localrepo.newreporequirements(repo)
 
     noremovereqs = (repo.requirements - newreqs -
                    upgradesupportremovedrequirements(repo))
     if noremovereqs:
         raise error.Abort(_('cannot upgrade repository; requirement would be '
                             'removed: %s') % _(', ').join(sorted(noremovereqs)))
 
     noaddreqs = (newreqs - repo.requirements -
                  upgradeallowednewrequirements(repo))
     if noaddreqs:
         raise error.Abort(_('cannot upgrade repository; do not support adding '
                             'requirement: %s') %
                           _(', ').join(sorted(noaddreqs)))
 
     unsupportedreqs = newreqs - upgradesupporteddestrequirements(repo)
     if unsupportedreqs:
         raise error.Abort(_('cannot upgrade repository; do not support '
                             'destination requirement: %s') %
                           _(', ').join(sorted(unsupportedreqs)))
 
     # Find and validate all improvements that can be made.
     improvements = upgradefindimprovements(repo)
     for i in improvements:
         if i.type not in (deficiency, optimisation):
             raise error.Abort(_('unexpected improvement type %s for %s') % (
                 i.type, i.name))
 
     # Validate arguments.
     unknownoptimize = optimize - set(i.name for i in improvements
                                      if i.type == optimisation)
     if unknownoptimize:
         raise error.Abort(_('unknown optimization action requested: %s') %
                           ', '.join(sorted(unknownoptimize)),
                           hint=_('run without arguments to see valid '
                                  'optimizations'))
 
     actions = upgradedetermineactions(repo, improvements, repo.requirements,
                                       newreqs, optimize)
 
     def printrequirements():
         ui.write(_('requirements\n'))
         ui.write(_('   preserved: %s\n') %
                  _(', ').join(sorted(newreqs & repo.requirements)))
 
         if repo.requirements - newreqs:
             ui.write(_('   removed: %s\n') %
                      _(', ').join(sorted(repo.requirements - newreqs)))
 
         if newreqs - repo.requirements:
             ui.write(_('   added: %s\n') %
                      _(', ').join(sorted(newreqs - repo.requirements)))
 
         ui.write('\n')
 
     def printupgradeactions():
         for action in actions:
             for i in improvements:
                 if i.name == action:
                     ui.write('%s\n   %s\n\n' %
                              (i.name, i.upgrademessage))
 
     if not run:
         fromdefault = []
         fromconfig = []
         optimizations = []
 
         for i in improvements:
             assert i.type in (deficiency, optimisation)
             if i.type == deficiency:
                 if i.fromdefault:
                     fromdefault.append(i)
                 if i.fromconfig:
                     fromconfig.append(i)
             else:
                 optimizations.append(i)
 
         if fromdefault or fromconfig:
             fromconfignames = set(x.name for x in fromconfig)
             onlydefault = [i for i in fromdefault
                            if i.name not in fromconfignames]
 
             if fromconfig:
                 ui.write(_('repository lacks features recommended by '
                            'current config options:\n\n'))
                 for i in fromconfig:
                     ui.write('%s\n   %s\n\n' % (i.name, i.description))
 
             if onlydefault:
                 ui.write(_('repository lacks features used by the default '
                            'config options:\n\n'))
                 for i in onlydefault:
                     ui.write('%s\n   %s\n\n' % (i.name, i.description))
 
             ui.write('\n')
         else:
             ui.write(_('(no feature deficiencies found in existing '
                        'repository)\n'))
 
         ui.write(_('performing an upgrade with "--run" will make the following '
                    'changes:\n\n'))
 
         printrequirements()
         printupgradeactions()
 
         unusedoptimize = [i for i in improvements
                           if i.name not in actions and i.type == optimisation]
         if unusedoptimize:
             ui.write(_('additional optimizations are available by specifying '
                      '"--optimize <name>":\n\n'))
             for i in unusedoptimize:
                 ui.write(_('%s\n   %s\n\n') % (i.name, i.description))
         return
 
     # Else we're in the run=true case.
     ui.write(_('upgrade will perform the following actions:\n\n'))
     printrequirements()
     printupgradeactions()
 
     ui.write(_('beginning upgrade...\n'))
     with repo.wlock():
         with repo.lock():
             ui.write(_('repository locked and read-only\n'))
             # Our strategy for upgrading the repository is to create a new,
             # temporary repository, write data to it, then do a swap of the
             # data. There are less heavyweight ways to do this, but it is easier
             # to create a new repo object than to instantiate all the components
             # (like the store) separately.
             tmppath = tempfile.mkdtemp(prefix='upgrade.', dir=repo.path)
             backuppath = None
             try:
                 ui.write(_('creating temporary repository to stage migrated '
                            'data: %s\n') % tmppath)
                 dstrepo = localrepo.localrepository(repo.baseui,
                                                     path=tmppath,
                                                     create=True)
 
                 with dstrepo.wlock():
                     with dstrepo.lock():
                         backuppath = _upgraderepo(ui, repo, dstrepo, newreqs,
                                                   actions)
 
             finally:
                 ui.write(_('removing temporary repository %s\n') % tmppath)
                 repo.vfs.rmtree(tmppath, forcibly=True)
 
                 if backuppath:
                     ui.warn(_('copy of old repository backed up at %s\n') %
                             backuppath)
                     ui.warn(_('the old repository will not be deleted; remove '
                               'it to free up disk space once the upgraded '
                               'repository is verified\n'))