mercurial: comparison mercurial/upgrade.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 from .utils import compression
 # list of requirements that request a clone of all revlog if added/removed
 RECLONES_REQUIREMENTS = {
-'generaldelta',
+b'generaldelta',
 localrepo.SPARSEREVLOG_REQUIREMENT,
 }
 def requiredsourcerequirements(repo):
 An upgrade will not be allowed if the repository doesn't have the
 requirements returned by this function.
 """
 return {
 # Introduced in Mercurial 0.9.2.
-'revlogv1',
+b'revlogv1',
 # Introduced in Mercurial 0.9.2.
-'store',
+b'store',
 }
 def blocksourcerequirements(repo):
 """Obtain requirements that will prevent an upgrade from occurring.
 requirements in the returned set.
 """
 return {
 # The upgrade code does not yet support these experimental features.
 # This is an artificial limitation.
-'treemanifest',
+b'treemanifest',
 # This was a precursor to generaldelta and was never enabled by default.
 # It should (hopefully) not exist in the wild.
-'parentdelta',
+b'parentdelta',
 # Upgrade should operate on the actual store, not the shared link.
-'shared',
+b'shared',
 }
 def supportremovedrequirements(repo):
 """Obtain requirements that can be removed during an upgrade.
 }
 for name in compression.compengines:
 engine = compression.compengines[name]
 if engine.available() and engine.revlogheader():
 supported.add(b'exp-compression-%s' % name)
-if engine.name() == 'zstd':
+if engine.name() == b'zstd':
 supported.add(b'revlog-compression-zstd')
 return supported
 def supporteddestrequirements(repo):
 the upgrade is disallowed.
 Extensions should monkeypatch this to add their custom requirements.
 """
 supported = {
-'dotencode',
+b'dotencode',
-'fncache',
+b'fncache',
-'generaldelta',
+b'generaldelta',
-'revlogv1',
+b'revlogv1',
-'store',
+b'store',
 localrepo.SPARSEREVLOG_REQUIREMENT,
 }
 for name in compression.compengines:
 engine = compression.compengines[name]
 if engine.available() and engine.revlogheader():
 supported.add(b'exp-compression-%s' % name)
-if engine.name() == 'zstd':
+if engine.name() == b'zstd':
 supported.add(b'revlog-compression-zstd')
 return supported
 def allowednewrequirements(repo):
 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.
 """
 supported = {
-'dotencode',
+b'dotencode',
-'fncache',
+b'fncache',
-'generaldelta',
+b'generaldelta',
 localrepo.SPARSEREVLOG_REQUIREMENT,
 }
 for name in compression.compengines:
 engine = compression.compengines[name]
 if engine.available() and engine.revlogheader():
 supported.add(b'exp-compression-%s' % name)
-if engine.name() == 'zstd':
+if engine.name() == b'zstd':
 supported.add(b'revlog-compression-zstd')
 return supported
 def preservedrequirements(repo):
 return set()
-deficiency = 'deficiency'
+deficiency = b'deficiency'
-optimisation = 'optimization'
+optimisation = b'optimization'
 class improvement(object):
 """Represents an improvement that can be made as part of an upgrade.
 return cls._requirement in cls._newreporequirements(repo.ui)
 @registerformatvariant
 class fncache(requirementformatvariant):
-name = 'fncache'
+name = b'fncache'
-_requirement = 'fncache'
+_requirement = b'fncache'
 default = True
 description = _(
-'long and reserved filenames may not work correctly; '
+b'long and reserved filenames may not work correctly; '
-'repository performance is sub-optimal'
+b'repository performance is sub-optimal'
 )
 upgrademessage = _(
-'repository will be more resilient to storing '
+b'repository will be more resilient to storing '
-'certain paths and performance of certain '
+b'certain paths and performance of certain '
-'operations should be improved'
+b'operations should be improved'
 )
 @registerformatvariant
 class dotencode(requirementformatvariant):
-name = 'dotencode'
+name = b'dotencode'
-_requirement = 'dotencode'
+_requirement = b'dotencode'
 default = True
 description = _(
-'storage of filenames beginning with a period or '
+b'storage of filenames beginning with a period or '
-'space may not work correctly'
+b'space may not work correctly'
 )
 upgrademessage = _(
-'repository will be better able to store files '
+b'repository will be better able to store files '
-'beginning with a space or period'
+b'beginning with a space or period'
 )
 @registerformatvariant
 class generaldelta(requirementformatvariant):
-name = 'generaldelta'
+name = b'generaldelta'
-_requirement = 'generaldelta'
+_requirement = b'generaldelta'
 default = True
 description = _(
-'deltas within internal storage are unable to '
+b'deltas within internal storage are unable to '
-'choose optimal revisions; repository is larger and '
+b'choose optimal revisions; repository is larger and '
-'slower than it could be; interaction with other '
+b'slower than it could be; interaction with other '
-'repositories may require extra network and CPU '
+b'repositories may require extra network and CPU '
-'resources, making "hg push" and "hg pull" slower'
+b'resources, making "hg push" and "hg pull" slower'
 )
 upgrademessage = _(
-'repository storage will be able to create '
+b'repository storage will be able to create '
-'optimal deltas; new repository data will be '
+b'optimal deltas; new repository data will be '
-'smaller and read times should decrease; '
+b'smaller and read times should decrease; '
-'interacting with other repositories using this '
+b'interacting with other repositories using this '
-'storage model should require less network and '
+b'storage model should require less network and '
-'CPU resources, making "hg push" and "hg pull" '
+b'CPU resources, making "hg push" and "hg pull" '
-'faster'
+b'faster'
 )
 @registerformatvariant
 class sparserevlog(requirementformatvariant):
-name = 'sparserevlog'
+name = b'sparserevlog'
 _requirement = localrepo.SPARSEREVLOG_REQUIREMENT
 default = True
 description = _(
-'in order to limit disk reading and memory usage on older '
+b'in order to limit disk reading and memory usage on older '
-'version, the span of a delta chain from its root to its '
+b'version, the span of a delta chain from its root to its '
-'end is limited, whatever the relevant data in this span. '
+b'end is limited, whatever the relevant data in this span. '
-'This can severly limit Mercurial ability to build good '
+b'This can severly limit Mercurial ability to build good '
-'chain of delta resulting is much more storage space being '
+b'chain of delta resulting is much more storage space being '
-'taken and limit reusability of on disk delta during '
+b'taken and limit reusability of on disk delta during '
-'exchange.'
+b'exchange.'
 )
 upgrademessage = _(
-'Revlog supports delta chain with more unused data '
+b'Revlog supports delta chain with more unused data '
-'between payload. These gaps will be skipped at read '
+b'between payload. These gaps will be skipped at read '
-'time. This allows for better delta chains, making a '
+b'time. This allows for better delta chains, making a '
-'better compression and faster exchange with server.'
+b'better compression and faster exchange with server.'
 )
 @registerformatvariant
 class sidedata(requirementformatvariant):
-name = 'sidedata'
+name = b'sidedata'
 _requirement = localrepo.SIDEDATA_REQUIREMENT
 default = False
 description = _(
-'Allows storage of extra data alongside a revision, '
+b'Allows storage of extra data alongside a revision, '
-'unlocking various caching options.'
+b'unlocking various caching options.'
 )
-upgrademessage = _('Allows storage of extra data alongside a revision.')
+upgrademessage = _(b'Allows storage of extra data alongside a revision.')
 @registerformatvariant
 class removecldeltachain(formatvariant):
-name = 'plain-cl-delta'
+name = b'plain-cl-delta'
 default = True
 description = _(
-'changelog storage is using deltas instead of '
+b'changelog storage is using deltas instead of '
-'raw entries; changelog reading and any '
+b'raw entries; changelog reading and any '
-'operation relying on changelog data are slower '
+b'operation relying on changelog data are slower '
-'than they could be'
+b'than they could be'
 )
 upgrademessage = _(
-'changelog storage will be reformated to '
+b'changelog storage will be reformated to '
-'store raw entries; changelog reading will be '
+b'store raw entries; changelog reading will be '
-'faster; changelog size may be reduced'
+b'faster; changelog size may be reduced'
 )
 @staticmethod
 def fromrepo(repo):
 # Mercurial 4.0 changed changelogs to not use delta chains. Search for
 return True
 @registerformatvariant
 class compressionengine(formatvariant):
-name = 'compression'
+name = b'compression'
-default = 'zlib'
+default = b'zlib'
 description = _(
-'Compresion algorithm used to compress data. '
+b'Compresion algorithm used to compress data. '
-'Some engine are faster than other'
+b'Some engine are faster than other'
 )
 upgrademessage = _(
-'revlog content will be recompressed with the new ' 'algorithm.'
+b'revlog content will be recompressed with the new ' b'algorithm.'
 )
 @classmethod
 def fromrepo(cls, repo):
 # we allow multiple compression engine requirement to co-exist because
 # strickly speaking, revlog seems to support mixed compression style.
 #
 # The compression used for new entries will be "the last one"
-compression = 'zlib'
+compression = b'zlib'
 for req in repo.requirements:
 prefix = req.startswith
-if prefix('revlog-compression-') or prefix('exp-compression-'):
+if prefix(b'revlog-compression-') or prefix(b'exp-compression-'):
-compression = req.split('-', 2)[2]
+compression = req.split(b'-', 2)[2]
 return compression
 @classmethod
 def fromconfig(cls, repo):
-return repo.ui.config('format', 'revlog-compression')
+return repo.ui.config(b'format', b'revlog-compression')
 @registerformatvariant
 class compressionlevel(formatvariant):
-name = 'compression-level'
+name = b'compression-level'
-default = 'default'
+default = b'default'
-description = _('compression level')
+description = _(b'compression level')
-upgrademessage = _('revlog content will be recompressed')
+upgrademessage = _(b'revlog content will be recompressed')
 @classmethod
 def fromrepo(cls, repo):
 comp = compressionengine.fromrepo(repo)
 level = None
-if comp == 'zlib':
+if comp == b'zlib':
-level = repo.ui.configint('storage', 'revlog.zlib.level')
+level = repo.ui.configint(b'storage', b'revlog.zlib.level')
-elif comp == 'zstd':
+elif comp == b'zstd':
-level = repo.ui.configint('storage', 'revlog.zstd.level')
+level = repo.ui.configint(b'storage', b'revlog.zstd.level')
 if level is None:
-return 'default'
+return b'default'
 return bytes(level)
 @classmethod
 def fromconfig(cls, repo):
 comp = compressionengine.fromconfig(repo)
 level = None
-if comp == 'zlib':
+if comp == b'zlib':
-level = repo.ui.configint('storage', 'revlog.zlib.level')
+level = repo.ui.configint(b'storage', b'revlog.zlib.level')
-elif comp == 'zstd':
+elif comp == b'zstd':
-level = repo.ui.configint('storage', 'revlog.zstd.level')
+level = repo.ui.configint(b'storage', b'revlog.zstd.level')
 if level is None:
-return 'default'
+return b'default'
 return bytes(level)
 def finddeficiencies(repo):
 """returns a list of deficiencies that the repo suffer from"""
 # We don't enforce backward compatibility for debug command so this
 # might eventually be dropped. However, having to use two different
 # forms in script when comparing result is anoying enough to add
 # backward compatibility for a while.
 legacy_opts_map = {
-'redeltaparent': 're-delta-parent',
+b'redeltaparent': b're-delta-parent',
-'redeltamultibase': 're-delta-multibase',
+b'redeltamultibase': b're-delta-multibase',
-'redeltaall': 're-delta-all',
+b'redeltaall': b're-delta-all',
-'redeltafulladd': 're-delta-fulladd',
+b'redeltafulladd': b're-delta-fulladd',
 }
 def findoptimizations(repo):
 """Determine optimisation that could be used during upgrade"""
 # which ones to apply.
 optimizations = []
 optimizations.append(
 improvement(
-name='re-delta-parent',
+name=b're-delta-parent',
 type=optimisation,
 description=_(
-'deltas within internal storage will be recalculated to '
+b'deltas within internal storage will be recalculated to '
-'choose an optimal base revision where this was not '
+b'choose an optimal base revision where this was not '
-'already done; the size of the repository may shrink and '
+b'already done; the size of the repository may shrink and '
-'various operations may become faster; the first time '
+b'various operations may become faster; the first time '
-'this optimization is performed could slow down upgrade '
+b'this optimization is performed could slow down upgrade '
-'execution considerably; subsequent invocations should '
+b'execution considerably; subsequent invocations should '
-'not run noticeably slower'
+b'not run noticeably slower'
 ),
 upgrademessage=_(
-'deltas within internal storage will choose a new '
+b'deltas within internal storage will choose a new '
-'base revision if needed'
+b'base revision if needed'
 ),
 )
 )
 optimizations.append(
 improvement(
-name='re-delta-multibase',
+name=b're-delta-multibase',
 type=optimisation,
 description=_(
-'deltas within internal storage will be recalculated '
+b'deltas within internal storage will be recalculated '
-'against multiple base revision and the smallest '
+b'against multiple base revision and the smallest '
-'difference will be used; the size of the repository may '
+b'difference will be used; the size of the repository may '
-'shrink significantly when there are many merges; this '
+b'shrink significantly when there are many merges; this '
-'optimization will slow down execution in proportion to '
+b'optimization will slow down execution in proportion to '
-'the number of merges in the repository and the amount '
+b'the number of merges in the repository and the amount '
-'of files in the repository; this slow down should not '
+b'of files in the repository; this slow down should not '
-'be significant unless there are tens of thousands of '
+b'be significant unless there are tens of thousands of '
-'files and thousands of merges'
+b'files and thousands of merges'
 ),
 upgrademessage=_(
-'deltas within internal storage will choose an '
+b'deltas within internal storage will choose an '
-'optimal delta by computing deltas against multiple '
+b'optimal delta by computing deltas against multiple '
-'parents; may slow down execution time '
+b'parents; may slow down execution time '
-'significantly'
+b'significantly'
 ),
 )
 )
 optimizations.append(
 improvement(
-name='re-delta-all',
+name=b're-delta-all',
 type=optimisation,
 description=_(
-'deltas within internal storage will always be '
+b'deltas within internal storage will always be '
-'recalculated without reusing prior deltas; this will '
+b'recalculated without reusing prior deltas; this will '
-'likely make execution run several times slower; this '
+b'likely make execution run several times slower; this '
-'optimization is typically not needed'
+b'optimization is typically not needed'
 ),
 upgrademessage=_(
-'deltas within internal storage will be fully '
+b'deltas within internal storage will be fully '
-'recomputed; this will likely drastically slow down '
+b'recomputed; this will likely drastically slow down '
-'execution time'
+b'execution time'
 ),
 )
 )
 optimizations.append(
 improvement(
-name='re-delta-fulladd',
+name=b're-delta-fulladd',
 type=optimisation,
 description=_(
-'every revision will be re-added as if it was new '
+b'every revision will be re-added as if it was new '
-'content. It will go through the full storage '
+b'content. It will go through the full storage '
-'mechanism giving extensions a chance to process it '
+b'mechanism giving extensions a chance to process it '
-'(eg. lfs). This is similar to "re-delta-all" but even '
+b'(eg. lfs). This is similar to "re-delta-all" but even '
-'slower since more logic is involved.'
+b'slower since more logic is involved.'
 ),
 upgrademessage=_(
-'each revision will be added as new content to the '
+b'each revision will be added as new content to the '
-'internal storage; this will likely drastically slow '
+b'internal storage; this will likely drastically slow '
-'down execution time, but some extensions might need '
+b'down execution time, but some extensions might need '
-'it'
+b'it'
 ),
 )
 )
 return optimizations
 def _revlogfrompath(repo, path):
 """Obtain a revlog from a repo path.
 An instance of the appropriate class is returned.
 """
-if path == '00changelog.i':
+if path == b'00changelog.i':
 return changelog.changelog(repo.svfs)
-elif path.endswith('00manifest.i'):
+elif path.endswith(b'00manifest.i'):
-mandir = path[: -len('00manifest.i')]
+mandir = path[: -len(b'00manifest.i')]
 return manifest.manifestrevlog(repo.svfs, tree=mandir)
 else:
 # reverse of "/".join(("data", path + ".i"))
 return filelog.filelog(repo.svfs, path[5:-2])
 oldindex = oldvfs.join(oldrl.indexfile)
 newindex = newvfs.join(newrl.indexfile)
 olddata = oldvfs.join(oldrl.datafile)
 newdata = newvfs.join(newrl.datafile)
-with newvfs(newrl.indexfile, 'w'):
+with newvfs(newrl.indexfile, b'w'):
 pass  # create all the directories
 util.copyfile(oldindex, newindex)
 copydata = oldrl.opener.exists(oldrl.datafile)
 if copydata:
 util.copyfile(olddata, newdata)
 if not (
-unencodedname.endswith('00changelog.i')
+unencodedname.endswith(b'00changelog.i')
-or unencodedname.endswith('00manifest.i')
+or unencodedname.endswith(b'00manifest.i')
 ):
 destrepo.svfs.fncache.add(unencodedname)
 if copydata:
-destrepo.svfs.fncache.add(unencodedname[:-2] + '.d')
+destrepo.svfs.fncache.add(unencodedname[:-2] + b'.d')
 UPGRADE_CHANGELOG = object()
 UPGRADE_MANIFEST = object()
 UPGRADE_FILELOG = object()
 def matchrevlog(revlogfilter, entry):
 """check is a revlog is selected for cloning
 The store entry is checked against the passed filter"""
-if entry.endswith('00changelog.i'):
+if entry.endswith(b'00changelog.i'):
 return UPGRADE_CHANGELOG in revlogfilter
-elif entry.endswith('00manifest.i'):
+elif entry.endswith(b'00manifest.i'):
 return UPGRADE_MANIFEST in revlogfilter
 return UPGRADE_FILELOG in revlogfilter
 def _clonerevlogs(
 alldatafiles = list(srcrepo.store.walk())
 # 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 alldatafiles:
-if unencoded.endswith('.d'):
+if unencoded.endswith(b'.d'):
 continue
 rl = _revlogfrompath(srcrepo, unencoded)
 info = rl.storageinfo(
 revisionscount=True,
 trackedsize=True,
 storedsize=True,
 )
-revcount += info['revisionscount'] or 0
+revcount += info[b'revisionscount'] or 0
-datasize = info['storedsize'] or 0
+datasize = info[b'storedsize'] or 0
-rawsize = info['trackedsize'] or 0
+rawsize = info[b'trackedsize'] or 0
 srcsize += datasize
 srcrawsize += rawsize
 # This is for the separate progress bars.
 fcount += 1
 frevcount += len(rl)
 fsrcsize += datasize
 frawsize += rawsize
 else:
-error.ProgrammingError('unknown revlog type')
+error.ProgrammingError(b'unknown revlog type')
 if not revcount:
 return
 ui.write(
 _(
-'migrating %d total revisions (%d in filelogs, %d in manifests, '
+b'migrating %d total revisions (%d in filelogs, %d in manifests, '
-'%d in changelog)\n'
+b'%d in changelog)\n'
 )
 % (revcount, frevcount, mrevcount, crevcount)
 )
 ui.write(
-_('migrating %s in store; %s tracked data\n')
+_(b'migrating %s in store; %s tracked data\n')
 % ((util.bytecount(srcsize), util.bytecount(srcrawsize)))
 )
 # Used to keep track of progress.
 progress = None
 # Do the actual copying.
 # FUTURE this operation can be farmed off to worker processes.
 seen = set()
 for unencoded, encoded, size in alldatafiles:
-if unencoded.endswith('.d'):
+if unencoded.endswith(b'.d'):
 continue
 oldrl = _revlogfrompath(srcrepo, unencoded)
-if isinstance(oldrl, changelog.changelog) and 'c' not in seen:
+if isinstance(oldrl, changelog.changelog) and b'c' not in seen:
 ui.write(
 _(
-'finished migrating %d manifest revisions across %d '
+b'finished migrating %d manifest revisions across %d '
-'manifests; change in size: %s\n'
+b'manifests; change in size: %s\n'
 )
 % (mrevcount, mcount, util.bytecount(mdstsize - msrcsize))
 )
 ui.write(
 _(
-'migrating changelog containing %d revisions '
+b'migrating changelog containing %d revisions '
-'(%s in store; %s tracked data)\n'
+b'(%s in store; %s tracked data)\n'
 )
 % (
 crevcount,
 util.bytecount(csrcsize),
 util.bytecount(crawsize),
 )
 )
-seen.add('c')
+seen.add(b'c')
 progress = srcrepo.ui.makeprogress(
-_('changelog revisions'), total=crevcount
+_(b'changelog revisions'), total=crevcount
 )
-elif isinstance(oldrl, manifest.manifestrevlog) and 'm' not in seen:
+elif isinstance(oldrl, manifest.manifestrevlog) and b'm' not in seen:
 ui.write(
 _(
-'finished migrating %d filelog revisions across %d '
+b'finished migrating %d filelog revisions across %d '
-'filelogs; change in size: %s\n'
+b'filelogs; change in size: %s\n'
 )
 % (frevcount, fcount, util.bytecount(fdstsize - fsrcsize))
 )
 ui.write(
 _(
-'migrating %d manifests containing %d revisions '
+b'migrating %d manifests containing %d revisions '
-'(%s in store; %s tracked data)\n'
+b'(%s in store; %s tracked data)\n'
 )
 % (
 mcount,
 mrevcount,
 util.bytecount(msrcsize),
 util.bytecount(mrawsize),
 )
 )
-seen.add('m')
+seen.add(b'm')
 if progress:
 progress.complete()
 progress = srcrepo.ui.makeprogress(
-_('manifest revisions'), total=mrevcount
+_(b'manifest revisions'), total=mrevcount
 )
-elif 'f' not in seen:
+elif b'f' not in seen:
 ui.write(
 _(
-'migrating %d filelogs containing %d revisions '
+b'migrating %d filelogs containing %d revisions '
-'(%s in store; %s tracked data)\n'
+b'(%s in store; %s tracked data)\n'
 )
 % (
 fcount,
 frevcount,
 util.bytecount(fsrcsize),
 util.bytecount(frawsize),
 )
 )
-seen.add('f')
+seen.add(b'f')
 if progress:
 progress.complete()
 progress = srcrepo.ui.makeprogress(
-_('file revisions'), total=frevcount
+_(b'file revisions'), total=frevcount
 )
 if matchrevlog(revlogs, unencoded):
 ui.note(
-_('cloning %d revisions from %s\n') % (len(oldrl), unencoded)
+_(b'cloning %d revisions from %s\n') % (len(oldrl), unencoded)
 )
 newrl = _revlogfrompath(dstrepo, unencoded)
 oldrl.clone(
 tr,
 newrl,
 addrevisioncb=oncopiedrevision,
 deltareuse=deltareuse,
 forcedeltabothparents=forcedeltabothparents,
 )
 else:
-msg = _('blindly copying %s containing %i revisions\n')
+msg = _(b'blindly copying %s containing %i revisions\n')
 ui.note(msg % (unencoded, len(oldrl)))
 _copyrevlog(tr, dstrepo, oldrl, unencoded)
 newrl = _revlogfrompath(dstrepo, unencoded)
 info = newrl.storageinfo(storedsize=True)
-datasize = info['storedsize'] or 0
+datasize = info[b'storedsize'] or 0
 dstsize += datasize
 if isinstance(newrl, changelog.changelog):
 cdstsize += datasize
 fdstsize += datasize
 progress.complete()
 ui.write(
-_('finished migrating %d changelog revisions; change in size: ' '%s\n')
+_(
+b'finished migrating %d changelog revisions; change in size: '
+b'%s\n'
+)
 % (crevcount, util.bytecount(cdstsize - csrcsize))
 )
 ui.write(
 _(
-'finished migrating %d total revisions; total change in store '
+b'finished migrating %d total revisions; total change in store '
-'size: %s\n'
+b'size: %s\n'
 )
 % (revcount, util.bytecount(dstsize - srcsize))
 )
 st: ``stat`` data structure for ``path``
 Function should return ``True`` if the file is to be copied.
 """
 # Skip revlogs.
-if path.endswith(('.i', '.d')):
+if path.endswith((b'.i', b'.d')):
 return False
 # Skip transaction related files.
-if path.startswith('undo'):
+if path.startswith(b'undo'):
 return False
 # Only copy regular files.
 if mode != stat.S_IFREG:
 return False
 # Skip other skipped files.
-if path in ('lock', 'fncache'):
+if path in (b'lock', b'fncache'):
 return False
 return True
 assert srcrepo.currentwlock()
 assert dstrepo.currentwlock()
 ui.write(
 _(
-'(it is safe to interrupt this process any time before '
+b'(it is safe to interrupt this process any time before '
-'data migration completes)\n'
+b'data migration completes)\n'
 )
 )
-if 're-delta-all' in actions:
+if b're-delta-all' in actions:
 deltareuse = revlog.revlog.DELTAREUSENEVER
-elif 're-delta-parent' in actions:
+elif b're-delta-parent' in actions:
 deltareuse = revlog.revlog.DELTAREUSESAMEREVS
-elif 're-delta-multibase' in actions:
+elif b're-delta-multibase' in actions:
 deltareuse = revlog.revlog.DELTAREUSESAMEREVS
-elif 're-delta-fulladd' in actions:
+elif b're-delta-fulladd' in actions:
 deltareuse = revlog.revlog.DELTAREUSEFULLADD
 else:
 deltareuse = revlog.revlog.DELTAREUSEALWAYS
-with dstrepo.transaction('upgrade') as tr:
+with dstrepo.transaction(b'upgrade') as tr:
 _clonerevlogs(
 ui,
 srcrepo,
 dstrepo,
 tr,
 deltareuse,
-'re-delta-multibase' in actions,
+b're-delta-multibase' in actions,
 revlogs=revlogs,
 )
 # Now copy other files in the store directory.
 # The sorted() makes execution deterministic.
-for p, kind, st in sorted(srcrepo.store.vfs.readdir('', stat=True)):
+for p, kind, st in sorted(srcrepo.store.vfs.readdir(b'', stat=True)):
 if not _filterstorefile(srcrepo, dstrepo, requirements, p, kind, st):
 continue
-srcrepo.ui.write(_('copying %s\n') % p)
+srcrepo.ui.write(_(b'copying %s\n') % p)
 src = srcrepo.store.rawvfs.join(p)
 dst = dstrepo.store.rawvfs.join(p)
 util.copyfile(src, dst, copystat=True)
 _finishdatamigration(ui, srcrepo, dstrepo, requirements)
-ui.write(_('data fully migrated to temporary repository\n'))
+ui.write(_(b'data fully migrated to temporary repository\n'))
-backuppath = pycompat.mkdtemp(prefix='upgradebackup.', dir=srcrepo.path)
+backuppath = pycompat.mkdtemp(prefix=b'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'))
+util.copyfile(srcrepo.vfs.join(b'requires'), backupvfs.join(b'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 '
+b'marking source repository as being upgraded; clients will be '
-'unable to read from repository\n'
+b'unable to read from repository\n'
 )
 )
 scmutil.writerequires(
-srcrepo.vfs, srcrepo.requirements | {'upgradeinprogress'}
+srcrepo.vfs, srcrepo.requirements | {b'upgradeinprogress'}
 )
-ui.write(_('starting in-place swap of repository data\n'))
+ui.write(_(b'starting in-place swap of repository data\n'))
-ui.write(_('replaced files will be backed up at %s\n') % backuppath)
+ui.write(_(b'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'))
+ui.write(_(b'replacing store...\n'))
 tstart = util.timer()
-util.rename(srcrepo.spath, backupvfs.join('store'))
+util.rename(srcrepo.spath, backupvfs.join(b'store'))
 util.rename(dstrepo.spath, srcrepo.spath)
 elapsed = util.timer() - tstart
 ui.write(
 _(
-'store replacement complete; repository was inconsistent for '
+b'store replacement complete; repository was inconsistent for '
-'%0.1fs\n'
+b'%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 '
+b'finalizing requirements file and making repository readable '
-'again\n'
+b'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')
+backupvfs.unlink(b'store/lock')
 return backuppath
 def upgraderepo(
 optimize = []
 optimize = set(legacy_opts_map.get(o, o) for o in optimize)
 repo = repo.unfiltered()
 revlogs = set(UPGRADE_ALL_REVLOGS)
-specentries = (('c', changelog), ('m', manifest))
+specentries = ((b'c', changelog), (b'm', manifest))
 specified = [(y, x) for (y, x) in specentries if x is not None]
 if specified:
 # we have some limitation on revlogs to be recloned
 if any(x for y, x in specified):
 revlogs = set()
 for r, enabled in specified:
 if enabled:
-if r == 'c':
+if r == b'c':
 revlogs.add(UPGRADE_CHANGELOG)
-elif r == 'm':
+elif r == b'm':
 revlogs.add(UPGRADE_MANIFEST)
 else:
 # none are enabled
 for r, __ in specified:
-if r == 'c':
+if r == b'c':
 revlogs.discard(UPGRADE_CHANGELOG)
-elif r == 'm':
+elif r == b'm':
 revlogs.discard(UPGRADE_MANIFEST)
 # Ensure the repository can be upgraded.
 missingreqs = requiredsourcerequirements(repo) - repo.requirements
 if missingreqs:
 raise error.Abort(
-_('cannot upgrade repository; requirement ' 'missing: %s')
+_(b'cannot upgrade repository; requirement ' b'missing: %s')
-% _(', ').join(sorted(missingreqs))
+% _(b', ').join(sorted(missingreqs))
 )
 blockedreqs = blocksourcerequirements(repo) & repo.requirements
 if blockedreqs:
 raise error.Abort(
 _(
-'cannot upgrade repository; unsupported source '
+b'cannot upgrade repository; unsupported source '
-'requirement: %s'
+b'requirement: %s'
 )
-% _(', ').join(sorted(blockedreqs))
+% _(b', ').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(
 noremovereqs = (
 repo.requirements - newreqs - supportremovedrequirements(repo)
 )
 if noremovereqs:
 raise error.Abort(
-_('cannot upgrade repository; requirement would be ' 'removed: %s')
+_(
-% _(', ').join(sorted(noremovereqs))
+b'cannot upgrade repository; requirement would be '
+b'removed: %s'
+)
+% _(b', ').join(sorted(noremovereqs))
 )
 noaddreqs = newreqs - repo.requirements - allowednewrequirements(repo)
 if noaddreqs:
 raise error.Abort(
 _(
-'cannot upgrade repository; do not support adding '
+b'cannot upgrade repository; do not support adding '
-'requirement: %s'
+b'requirement: %s'
 )
-% _(', ').join(sorted(noaddreqs))
+% _(b', ').join(sorted(noaddreqs))
 )
 unsupportedreqs = newreqs - supporteddestrequirements(repo)
 if unsupportedreqs:
 raise error.Abort(
 _(
-'cannot upgrade repository; do not support '
+b'cannot upgrade repository; do not support '
-'destination requirement: %s'
+b'destination requirement: %s'
 )
-% _(', ').join(sorted(unsupportedreqs))
+% _(b', ').join(sorted(unsupportedreqs))
 )
 # Find and validate all improvements that can be made.
 alloptimizations = findoptimizations(repo)
 optimizations.append(o)
 optimize.discard(o.name)
 if optimize:  # anything left is unknown
 raise error.Abort(
-_('unknown optimization action requested: %s')
+_(b'unknown optimization action requested: %s')
-% ', '.join(sorted(optimize)),
+% b', '.join(sorted(optimize)),
-hint=_('run without arguments to see valid ' 'optimizations'),
+hint=_(b'run without arguments to see valid ' b'optimizations'),
 )
 deficiencies = finddeficiencies(repo)
 actions = determineactions(repo, deficiencies, repo.requirements, newreqs)
 actions.extend(
 if revlogs != UPGRADE_ALL_REVLOGS:
 incompatible = RECLONES_REQUIREMENTS & (removedreqs | addedreqs)
 if incompatible:
 msg = _(
-'ignoring revlogs selection flags, format requirements '
+b'ignoring revlogs selection flags, format requirements '
-'change: %s\n'
+b'change: %s\n'
 )
-ui.warn(msg % ', '.join(sorted(incompatible)))
+ui.warn(msg % b', '.join(sorted(incompatible)))
 revlogs = UPGRADE_ALL_REVLOGS
 def printrequirements():
-ui.write(_('requirements\n'))
+ui.write(_(b'requirements\n'))
 ui.write(
-_('   preserved: %s\n')
+_(b'   preserved: %s\n')
-% _(', ').join(sorted(newreqs & repo.requirements))
+% _(b', ').join(sorted(newreqs & repo.requirements))
 )
 if repo.requirements - newreqs:
 ui.write(
-_('   removed: %s\n')
+_(b'   removed: %s\n')
-% _(', ').join(sorted(repo.requirements - newreqs))
+% _(b', ').join(sorted(repo.requirements - newreqs))
 )
 if newreqs - repo.requirements:
 ui.write(
-_('   added: %s\n')
+_(b'   added: %s\n')
-% _(', ').join(sorted(newreqs - repo.requirements))
+% _(b', ').join(sorted(newreqs - repo.requirements))
 )
-ui.write('\n')
+ui.write(b'\n')
 def printupgradeactions():
 for a in actions:
-ui.write('%s\n   %s\n\n' % (a.name, a.upgrademessage))
+ui.write(b'%s\n   %s\n\n' % (a.name, a.upgrademessage))
 if not run:
 fromconfig = []
 onlydefault = []
 if fromconfig or onlydefault:
 if fromconfig:
 ui.write(
 _(
-'repository lacks features recommended by '
+b'repository lacks features recommended by '
-'current config options:\n\n'
+b'current config options:\n\n'
 )
 )
 for i in fromconfig:
-ui.write('%s\n   %s\n\n' % (i.name, i.description))
+ui.write(b'%s\n   %s\n\n' % (i.name, i.description))
 if onlydefault:
 ui.write(
 _(
-'repository lacks features used by the default '
+b'repository lacks features used by the default '
-'config options:\n\n'
+b'config options:\n\n'
 )
 )
 for i in onlydefault:
-ui.write('%s\n   %s\n\n' % (i.name, i.description))
+ui.write(b'%s\n   %s\n\n' % (i.name, i.description))
-ui.write('\n')
+ui.write(b'\n')
 else:
 ui.write(
-_('(no feature deficiencies found in existing ' 'repository)\n')
+_(
+b'(no feature deficiencies found in existing '
+b'repository)\n'
+)
 )
 ui.write(
 _(
-'performing an upgrade with "--run" will make the following '
+b'performing an upgrade with "--run" will make the following '
-'changes:\n\n'
+b'changes:\n\n'
 )
 )
 printrequirements()
 printupgradeactions()
 unusedoptimize = [i for i in alloptimizations if i not in actions]
 if unusedoptimize:
 ui.write(
 _(
-'additional optimizations are available by specifying '
+b'additional optimizations are available by specifying '
-'"--optimize <name>":\n\n'
+b'"--optimize <name>":\n\n'
 )
 )
 for i in unusedoptimize:
-ui.write(_('%s\n   %s\n\n') % (i.name, i.description))
+ui.write(_(b'%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'))
+ui.write(_(b'upgrade will perform the following actions:\n\n'))
 printrequirements()
 printupgradeactions()
 upgradeactions = [a.name for a in actions]
-ui.write(_('beginning upgrade...\n'))
+ui.write(_(b'beginning upgrade...\n'))
 with repo.wlock(), repo.lock():
-ui.write(_('repository locked and read-only\n'))
+ui.write(_(b'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 = pycompat.mkdtemp(prefix='upgrade.', dir=repo.path)
+tmppath = pycompat.mkdtemp(prefix=b'upgrade.', dir=repo.path)
 backuppath = None
 try:
 ui.write(
 _(
-'creating temporary repository to stage migrated '
+b'creating temporary repository to stage migrated '
-'data: %s\n'
+b'data: %s\n'
 )
 % tmppath
 )
 # clone ui without using ui.copy because repo.ui is protected
 with dstrepo.wlock(), dstrepo.lock():
 backuppath = _upgraderepo(
 ui, repo, dstrepo, newreqs, upgradeactions, revlogs=revlogs
 )
 if not (backup or backuppath is None):
-ui.write(_('removing old repository content%s\n') % backuppath)
+ui.write(_(b'removing old repository content%s\n') % backuppath)
 repo.vfs.rmtree(backuppath, forcibly=True)
 backuppath = None
 finally:
-ui.write(_('removing temporary repository %s\n') % tmppath)
+ui.write(_(b'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
+_(b'copy of old repository backed up at %s\n') % backuppath
 )
 ui.warn(
 _(
-'the old repository will not be deleted; remove '
+b'the old repository will not be deleted; remove '
-'it to free up disk space once the upgraded '
+b'it to free up disk space once the upgraded '
-'repository is verified\n'
+b'repository is verified\n'
 )
 )

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43089	c59eb1560c44