mercurial: comparison mercurial/repair.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 def backupbundle(
 repo, bases, heads, node, suffix, compress=True, obsolescence=True
 ):
 """create a bundle with the specified revisions as a backup"""
-backupdir = "strip-backup"
+backupdir = b"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)
+allcommits = repo.set(b'%ln::%ln', bases, heads)
 allhashes = sorted(c.hex() for c in allcommits)
-totalhash = hashlib.sha1(''.join(allhashes)).digest()
+totalhash = hashlib.sha1(b''.join(allhashes)).digest()
-name = "%s/%s-%s-%s.hg" % (
+name = b"%s/%s-%s-%s.hg" % (
 backupdir,
 short(node),
 hex(totalhash[:4]),
 suffix,
 )
 cgversion = changegroup.localversion(repo)
 comp = None
-if cgversion != '01':
+if cgversion != b'01':
-bundletype = "HG20"
+bundletype = b"HG20"
 if compress:
-comp = 'BZ'
+comp = b'BZ'
 elif compress:
-bundletype = "HG10BZ"
+bundletype = b"HG10BZ"
 else:
-bundletype = "HG10UN"
+bundletype = b"HG10UN"
 outgoing = discovery.outgoing(repo, missingroots=bases, missingheads=heads)
 contentopts = {
-'cg.version': cgversion,
+b'cg.version': cgversion,
-'obsolescence': obsolescence,
+b'obsolescence': obsolescence,
-'phases': True,
+b'phases': True,
 }
 return bundle2.writenewbundle(
 repo.ui,
 repo,
-'strip',
+b'strip',
 name,
 bundletype,
 outgoing,
 contentopts,
 vfs,
 s.update(_collectrevlog(repo.file(fname), striprev))
 return s
-def strip(ui, repo, nodelist, backup=True, topic='backup'):
+def strip(ui, repo, nodelist, backup=True, topic=b'backup'):
 # This function requires the caller to lock the repo, but it operates
 # within a transaction of its own, and thus requires there to be no current
 # transaction when it is called.
 if repo.currenttransaction() is not None:
-raise error.ProgrammingError('cannot strip from inside a transaction')
+raise error.ProgrammingError(b'cannot strip from inside a transaction')
 # Simple way to maintain backwards compatibility for this
 # argument.
-if backup in ['none', 'strip']:
+if backup in [b'none', b'strip']:
 backup = False
 repo = repo.unfiltered()
 repo.destroying()
 vfs = repo.vfs
 saverevs.difference_update(descendants)
 savebases = [cl.node(r) for r in saverevs]
 stripbases = [cl.node(r) for r in tostrip]
 stripobsidx = obsmarkers = ()
-if repo.ui.configbool('devel', 'strip-obsmarkers'):
+if repo.ui.configbool(b'devel', b'strip-obsmarkers'):
 obsmarkers = obsutil.exclusivemarkers(repo, stripbases)
 if obsmarkers:
 stripobsidx = [
 i for i, m in enumerate(repo.obsstore) if m in obsmarkers
 ]
 tmpbundlefile = backupbundle(
 repo,
 savebases,
 saveheads,
 node,
-'temp',
+b'temp',
 compress=False,
 obsolescence=False,
 )
 with ui.uninterruptible():
 try:
-with repo.transaction("strip") as tr:
+with repo.transaction(b"strip") as tr:
 # TODO this code violates the interface abstraction of the
 # transaction and makes assumptions that file storage is
 # using append-only files. We'll need some kind of storage
 # API to handle stripping for us.
 offset = len(tr._entries)
 repo.file(fn).strip(striprev, tr)
 tr.endgroup()
 for i in pycompat.xrange(offset, len(tr._entries)):
 file, troffset, ignore = tr._entries[i]
-with repo.svfs(file, 'a', checkambig=True) as fp:
+with repo.svfs(file, b'a', checkambig=True) as fp:
 fp.truncate(troffset)
 if troffset == 0:
 repo.store.markremoved(file)
 deleteobsmarkers(repo.obsstore, stripobsidx)
 del repo.obsstore
 repo.invalidatevolatilesets()
 repo._phasecache.filterunknown(repo)
 if tmpbundlefile:
-ui.note(_("adding branch\n"))
+ui.note(_(b"adding branch\n"))
-f = vfs.open(tmpbundlefile, "rb")
+f = vfs.open(tmpbundlefile, b"rb")
 gen = exchange.readbundle(ui, f, tmpbundlefile, vfs)
 if not repo.ui.verbose:
 # silence internal shuffling chatter
 repo.ui.pushbuffer()
-tmpbundleurl = 'bundle:' + vfs.join(tmpbundlefile)
+tmpbundleurl = b'bundle:' + vfs.join(tmpbundlefile)
-txnname = 'strip'
+txnname = b'strip'
 if not isinstance(gen, bundle2.unbundle20):
-txnname = "strip\n%s" % util.hidepassword(tmpbundleurl)
+txnname = b"strip\n%s" % util.hidepassword(tmpbundleurl)
 with repo.transaction(txnname) as tr:
 bundle2.applybundle(
-repo, gen, tr, source='strip', url=tmpbundleurl
+repo, gen, tr, source=b'strip', url=tmpbundleurl
 )
 if not repo.ui.verbose:
 repo.ui.popbuffer()
 f.close()
-with repo.transaction('repair') as tr:
+with repo.transaction(b'repair') as tr:
 bmchanges = [(m, repo[newbmtarget].node()) for m in updatebm]
 repo._bookmarks.applychanges(repo, tr, bmchanges)
 # 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')
+_(b'error removing %s: %s\n')
 % (
 undovfs.join(undofile),
 stringutil.forcebytestr(e),
 )
 )
 except:  # re-raises
 if backupfile:
 ui.warn(
-_("strip failed, backup bundle stored in '%s'\n")
+_(b"strip failed, backup bundle stored in '%s'\n")
 % vfs.join(backupfile)
 )
 if tmpbundlefile:
 ui.warn(
-_("strip failed, unrecovered changes stored in '%s'\n")
+_(b"strip failed, unrecovered changes stored in '%s'\n")
 % vfs.join(tmpbundlefile)
 )
 ui.warn(
 _(
-"(fix the problem, then recover the changesets with "
+b"(fix the problem, then recover the changesets with "
-"\"hg unbundle '%s'\")\n"
+b"\"hg unbundle '%s'\")\n"
 )
 % vfs.join(tmpbundlefile)
 )
 raise
 else:
 # return the backup file path (or None if 'backup' was False) so
 # extensions can use it
 return backupfile
-def softstrip(ui, repo, nodelist, backup=True, topic='backup'):
+def softstrip(ui, repo, nodelist, backup=True, topic=b'backup'):
 """perform a "soft" strip using the archived phase"""
-tostrip = [c.node() for c in repo.set('sort(%ln::)', nodelist)]
+tostrip = [c.node() for c in repo.set(b'sort(%ln::)', nodelist)]
 if not tostrip:
 return None
 newbmtarget, updatebm = _bookmarkmovements(repo, tostrip)
 if backup:
 node = tostrip[0]
 backupfile = _createstripbackup(repo, tostrip, node, topic)
-with repo.transaction('strip') as tr:
+with repo.transaction(b'strip') as tr:
 phases.retractboundary(repo, tr, phases.archived, tostrip)
 bmchanges = [(m, repo[newbmtarget].node()) for m in updatebm]
 repo._bookmarks.applychanges(repo, tr, bmchanges)
 return backupfile
 # If we need to move bookmarks, compute bookmark
 # targets. Otherwise we can skip doing this logic.
 if updatebm:
 # 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)
+newbmtarget = repo.revs(b'max(parents(%ld) - (%ld))', tostrip, tostrip)
 if newbmtarget:
 newbmtarget = repo[newbmtarget.first()].node()
 else:
-newbmtarget = '.'
+newbmtarget = b'.'
 return newbmtarget, updatebm
 def _createstripbackup(repo, stripbases, node, topic):
 # backup the changeset we are about to strip
 vfs = repo.vfs
 cl = repo.changelog
 backupfile = backupbundle(repo, stripbases, cl.heads(), node, topic)
-repo.ui.status(_("saved backup bundle to %s\n") % vfs.join(backupfile))
+repo.ui.status(_(b"saved backup bundle to %s\n") % vfs.join(backupfile))
 repo.ui.log(
-"backupbundle", "saved backup bundle to %s\n", vfs.join(backupfile)
+b"backupbundle", b"saved backup bundle to %s\n", vfs.join(backupfile)
 )
 return backupfile
 def safestriproots(ui, repo, nodes):
 revs = set(torev(n) for n in nodes)
 # tostrip = wanted - unsafe = wanted - ancestors(orphaned)
 # orphaned = affected - wanted
 # affected = descendants(roots(wanted))
 # wanted = revs
-revset = '%ld - ( ::( (roots(%ld):: and not _phase(%s)) -%ld) )'
+revset = b'%ld - ( ::( (roots(%ld):: and not _phase(%s)) -%ld) )'
 tostrip = set(repo.revs(revset, revs, revs, phases.internal, revs))
 notstrip = revs - tostrip
 if notstrip:
-nodestr = ', '.join(sorted(short(repo[n].node()) for n in notstrip))
+nodestr = b', '.join(sorted(short(repo[n].node()) for n in notstrip))
 ui.warn(
-_('warning: orphaned descendants detected, ' 'not stripping %s\n')
+_(b'warning: orphaned descendants detected, ' b'not stripping %s\n')
 % nodestr
 )
-return [c.node() for c in repo.set('roots(%ld)', tostrip)]
+return [c.node() for c in repo.set(b'roots(%ld)', tostrip)]
 class stripcallback(object):
 """used as a transaction postclose callback"""
 def __init__(self, ui, repo, backup, topic):
 self.ui = ui
 self.repo = repo
 self.backup = backup
-self.topic = topic or 'backup'
+self.topic = topic or b'backup'
 self.nodelist = []
 def addnodes(self, nodes):
 self.nodelist.extend(nodes)
 if not tr:
 nodes = safestriproots(ui, repo, nodelist)
 return strip(ui, repo, nodes, backup=backup, topic=topic)
 # transaction postclose callbacks are called in alphabet order.
 # use '\xff' as prefix so we are likely to be called last.
-callback = tr.getpostclose('\xffstrip')
+callback = tr.getpostclose(b'\xffstrip')
 if callback is None:
 callback = stripcallback(ui, repo, backup=backup, topic=topic)
-tr.addpostclose('\xffstrip', callback)
+tr.addpostclose(b'\xffstrip', callback)
 if topic:
 callback.topic = topic
 callback.addnodes(nodelist)
 revlog.strip(striprev, tr)
 def manifestrevlogs(repo):
 yield repo.manifestlog.getstorage(b'')
-if 'treemanifest' in repo.requirements:
+if b'treemanifest' in repo.requirements:
 # This logic is safe if treemanifest isn't enabled, but also
 # pointless, so we skip it if treemanifest isn't enabled.
 for unencoded, encoded, size in repo.store.datafiles():
-if unencoded.startswith('meta/') and unencoded.endswith(
+if unencoded.startswith(b'meta/') and unencoded.endswith(
-'00manifest.i'
+b'00manifest.i'
 ):
 dir = unencoded[5:-12]
 yield repo.manifestlog.getstorage(dir)
 Missing entries will be added. Extra entries will be removed.
 """
 repo = repo.unfiltered()
-if 'fncache' not in repo.requirements:
+if b'fncache' not in repo.requirements:
 ui.warn(
 _(
-'(not rebuilding fncache because repository does not '
+b'(not rebuilding fncache because repository does not '
-'support fncache)\n'
+b'support fncache)\n'
 )
 )
 return
 with repo.lock():
 oldentries = set(fnc.entries)
 newentries = set()
 seenfiles = set()
 progress = ui.makeprogress(
-_('rebuilding'), unit=_('changesets'), total=len(repo)
+_(b'rebuilding'), unit=_(b'changesets'), total=len(repo)
 )
 for rev in repo:
 progress.update(rev)
 ctx = repo[rev]
 # This is to minimize I/O.
 if f in seenfiles:
 continue
 seenfiles.add(f)
-i = 'data/%s.i' % f
+i = b'data/%s.i' % f
-d = 'data/%s.d' % f
+d = b'data/%s.d' % f
 if repo.store._exists(i):
 newentries.add(i)
 if repo.store._exists(d):
 newentries.add(d)
 progress.complete()
-if 'treemanifest' in repo.requirements:
+if b'treemanifest' in repo.requirements:
 # This logic is safe if treemanifest isn't enabled, but also
 # pointless, so we skip it if treemanifest isn't enabled.
 for dir in util.dirs(seenfiles):
-i = 'meta/%s/00manifest.i' % dir
+i = b'meta/%s/00manifest.i' % dir
-d = 'meta/%s/00manifest.d' % dir
+d = b'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)
+ui.write(_(b'removing %s\n') % p)
 for p in sorted(newentries - oldentries):
-ui.write(_('adding %s\n') % p)
+ui.write(_(b'adding %s\n') % p)
 if addcount or removecount:
 ui.write(
-_('%d items added, %d removed from fncache\n')
+_(b'%d items added, %d removed from fncache\n')
 % (addcount, removecount)
 )
 fnc.entries = newentries
 fnc._dirty = True
-with repo.transaction('fncache') as tr:
+with repo.transaction(b'fncache') as tr:
 fnc.write(tr)
 else:
-ui.write(_('fncache already up to date\n'))
+ui.write(_(b'fncache already up to date\n'))
 def deleteobsmarkers(obsstore, indices):
 """Delete some obsmarkers from obsstore and return how many were deleted
 if i in indices:
 n += 1
 continue
 left.append(m)
-newobsstorefile = obsstore.svfs('obsstore', 'w', atomictemp=True)
+newobsstorefile = obsstore.svfs(b'obsstore', b'w', atomictemp=True)
 for bytes in obsolete.encodemarkers(left, True, obsstore._version):
 newobsstorefile.write(bytes)
 newobsstorefile.close()
 return n

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43117	8ff1ecfadcd1