mercurial: comparison mercurial/upgrade.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 scmutil,
 util,
 vfs as vfsmod,
 )
-from .utils import (
+from .utils import compression
-compression,
-)
 # list of requirements that request a clone of all revlog if added/removed
 RECLONES_REQUIREMENTS = {
 'generaldelta',
 localrepo.SPARSEREVLOG_REQUIREMENT,
 }
 def requiredsourcerequirements(repo):
 """Obtain requirements required to be present to upgrade a repo.
 An upgrade will not be allowed if the repository doesn't have the
 # Introduced in Mercurial 0.9.2.
 'revlogv1',
 # Introduced in Mercurial 0.9.2.
 'store',
 }
 def blocksourcerequirements(repo):
 """Obtain requirements that will prevent an upgrade from occurring.
 An upgrade cannot be performed if the source repository contains a
 # It should (hopefully) not exist in the wild.
 'parentdelta',
 # Upgrade should operate on the actual store, not the shared link.
 'shared',
 }
 def supportremovedrequirements(repo):
 """Obtain requirements that can be removed during an upgrade.
 If an upgrade were to create a repository that dropped a requirement,
 if engine.available() and engine.revlogheader():
 supported.add(b'exp-compression-%s' % name)
 if engine.name() == 'zstd':
 supported.add(b'revlog-compression-zstd')
 return supported
 def supporteddestrequirements(repo):
 """Obtain requirements that upgrade supports in the destination.
 If the result of the upgrade would create requirements not in this set,
 supported.add(b'exp-compression-%s' % name)
 if engine.name() == 'zstd':
 supported.add(b'revlog-compression-zstd')
 return supported
 def allowednewrequirements(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.
 supported.add(b'exp-compression-%s' % name)
 if engine.name() == 'zstd':
 supported.add(b'revlog-compression-zstd')
 return supported
 def preservedrequirements(repo):
 return set()
 deficiency = 'deficiency'
 optimisation = 'optimization'
 class improvement(object):
 """Represents an improvement that can be made as part of an upgrade.
 The following attributes are defined on each instance:
 upgrademessage
 Message intended for humans explaining what an upgrade addressing this
 issue will do. Should be worded in the future tense.
 """
 def __init__(self, name, type, description, upgrademessage):
 self.name = name
 self.type = type
 self.description = description
 self.upgrademessage = upgrademessage
 return not (self == other)
 def __hash__(self):
 return hash(self.name)
 allformatvariant = []
 def registerformatvariant(cls):
 allformatvariant.append(cls)
 return cls
 class formatvariant(improvement):
 """an improvement subclass dedicated to repository format"""
 type = deficiency
 ### The following attributes should be defined for each class:
 # machine-readable string uniquely identifying this improvement. it will be
 # mapped to an action later in the upgrade process.
 @staticmethod
 def fromconfig(repo):
 """current value of the variant in the configuration"""
 raise NotImplementedError()
 class requirementformatvariant(formatvariant):
 """formatvariant based on a 'requirement' name.
 Many format variant are controlled by a 'requirement'. We define a small
 subclass to factor the code.
 _requirement = None
 @staticmethod
 def _newreporequirements(ui):
 return localrepo.newreporequirements(
-ui, localrepo.defaultcreateopts(ui))
+ui, localrepo.defaultcreateopts(ui)
+)
 @classmethod
 def fromrepo(cls, repo):
 assert cls._requirement is not None
 return cls._requirement in repo.requirements
 @classmethod
 def fromconfig(cls, repo):
 assert cls._requirement is not None
 return cls._requirement in cls._newreporequirements(repo.ui)
 @registerformatvariant
 class fncache(requirementformatvariant):
 name = 'fncache'
 _requirement = 'fncache'
 default = True
-description = _('long and reserved filenames may not work correctly; '
+description = _(
-'repository performance is sub-optimal')
+'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')
+upgrademessage = _(
+'repository will be more resilient to storing '
+'certain paths and performance of certain '
+'operations should be improved'
+)
 @registerformatvariant
 class dotencode(requirementformatvariant):
 name = 'dotencode'
 _requirement = 'dotencode'
 default = True
-description = _('storage of filenames beginning with a period or '
+description = _(
-'space may not work correctly')
+'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')
+upgrademessage = _(
+'repository will be better able to store files '
+'beginning with a space or period'
+)
 @registerformatvariant
 class generaldelta(requirementformatvariant):
 name = 'generaldelta'
 _requirement = 'generaldelta'
 default = True
-description = _('deltas within internal storage are unable to '
+description = _(
-'choose optimal revisions; repository is larger and '
+'deltas within internal storage are unable to '
-'slower than it could be; interaction with other '
+'choose optimal revisions; repository is larger and '
-'repositories may require extra network and CPU '
+'slower than it could be; interaction with other '
-'resources, making "hg push" and "hg pull" slower')
+'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; '
+upgrademessage = _(
-'interacting with other repositories using this '
+'repository storage will be able to create '
-'storage model should require less network and '
+'optimal deltas; new repository data will be '
-'CPU resources, making "hg push" and "hg pull" '
+'smaller and read times should decrease; '
-'faster')
+'interacting with other repositories using this '
+'storage model should require less network and '
+'CPU resources, making "hg push" and "hg pull" '
+'faster'
+)
 @registerformatvariant
 class sparserevlog(requirementformatvariant):
 name = 'sparserevlog'
 _requirement = localrepo.SPARSEREVLOG_REQUIREMENT
 default = True
-description = _('in order to limit disk reading and memory usage on older '
+description = _(
-'version, the span of a delta chain from its root to its '
+'in order to limit disk reading and memory usage on older '
-'end is limited, whatever the relevant data in this span. '
+'version, the span of a delta chain from its root to its '
-'This can severly limit Mercurial ability to build good '
+'end is limited, whatever the relevant data in this span. '
-'chain of delta resulting is much more storage space being '
+'This can severly limit Mercurial ability to build good '
-'taken and limit reusability of on disk delta during '
+'chain of delta resulting is much more storage space being '
-'exchange.'
+'taken and limit reusability of on disk delta during '
-)
+'exchange.'
+)
-upgrademessage = _('Revlog supports delta chain with more unused data '
-'between payload. These gaps will be skipped at read '
+upgrademessage = _(
-'time. This allows for better delta chains, making a '
+'Revlog supports delta chain with more unused data '
-'better compression and faster exchange with server.')
+'between payload. These gaps will be skipped at read '
+'time. This allows for better delta chains, making a '
+'better compression and faster exchange with server.'
+)
 @registerformatvariant
 class sidedata(requirementformatvariant):
 name = 'sidedata'
 _requirement = localrepo.SIDEDATA_REQUIREMENT
 default = False
-description = _('Allows storage of extra data alongside a revision, '
+description = _(
-'unlocking various caching options.')
+'Allows storage of extra data alongside a revision, '
+'unlocking various caching options.'
+)
 upgrademessage = _('Allows storage of extra data alongside a revision.')
 @registerformatvariant
 class removecldeltachain(formatvariant):
 name = 'plain-cl-delta'
 default = True
-description = _('changelog storage is using deltas instead of '
+description = _(
-'raw entries; changelog reading and any '
+'changelog storage is using deltas instead of '
-'operation relying on changelog data are slower '
+'raw entries; changelog reading and any '
-'than they could be')
+'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')
+upgrademessage = _(
+'changelog storage will be reformated to '
+'store raw entries; changelog reading will be '
+'faster; changelog size may be reduced'
+)
 @staticmethod
 def fromrepo(repo):
 # Mercurial 4.0 changed changelogs to not use delta chains. Search for
 # changelogs with deltas.
 @staticmethod
 def fromconfig(repo):
 return True
 @registerformatvariant
 class compressionengine(formatvariant):
 name = 'compression'
 default = 'zlib'
-description = _('Compresion algorithm used to compress data. '
+description = _(
-'Some engine are faster than other')
+'Compresion algorithm used to compress data. '
+'Some engine are faster than other'
-upgrademessage = _('revlog content will be recompressed with the new '
+)
-'algorithm.')
+upgrademessage = _(
+'revlog content will be recompressed with the new ' '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.
 @classmethod
 def fromconfig(cls, repo):
 return repo.ui.config('format', 'revlog-compression')
 @registerformatvariant
 class compressionlevel(formatvariant):
 name = 'compression-level'
 default = 'default'
 level = repo.ui.configint('storage', 'revlog.zstd.level')
 if level is None:
 return 'default'
 return bytes(level)
 def finddeficiencies(repo):
 """returns a list of deficiencies that the repo suffer from"""
 deficiencies = []
 # We could detect lack of revlogv1 and store here, but they were added
 for fv in allformatvariant:
 if not fv.fromrepo(repo):
 deficiencies.append(fv)
 return deficiencies
 # search without '-' to support older form on newer client.
 #
 # We don't enforce backward compatibility for debug command so this
 # might eventually be dropped. However, having to use two different
 'redeltamultibase': 're-delta-multibase',
 'redeltaall': 're-delta-all',
 'redeltafulladd': 're-delta-fulladd',
 }
 def findoptimizations(repo):
 """Determine optimisation that could be used during upgrade"""
 # These are unconditionally added. There is logic later that figures out
 # which ones to apply.
 optimizations = []
-optimizations.append(improvement(
+optimizations.append(
-name='re-delta-parent',
+improvement(
-type=optimisation,
+name='re-delta-parent',
-description=_('deltas within internal storage will be recalculated to '
+type=optimisation,
-'choose an optimal base revision where this was not '
+description=_(
-'already done; the size of the repository may shrink and '
+'deltas within internal storage will be recalculated to '
-'various operations may become faster; the first time '
+'choose an optimal base revision where this was not '
-'this optimization is performed could slow down upgrade '
+'already done; the size of the repository may shrink and '
-'execution considerably; subsequent invocations should '
+'various operations may become faster; the first time '
-'not run noticeably slower'),
+'this optimization is performed could slow down upgrade '
-upgrademessage=_('deltas within internal storage will choose a new '
+'execution considerably; subsequent invocations should '
-'base revision if needed')))
+'not run noticeably slower'
+),
-optimizations.append(improvement(
+upgrademessage=_(
-name='re-delta-multibase',
+'deltas within internal storage will choose a new '
-type=optimisation,
+'base revision if needed'
-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 '
+optimizations.append(
-'the number of merges in the repository and the amount '
+improvement(
-'of files in the repository; this slow down should not '
+name='re-delta-multibase',
-'be significant unless there are tens of thousands of '
+type=optimisation,
-'files and thousands of merges'),
+description=_(
-upgrademessage=_('deltas within internal storage will choose an '
+'deltas within internal storage will be recalculated '
-'optimal delta by computing deltas against multiple '
+'against multiple base revision and the smallest '
-'parents; may slow down execution time '
+'difference will be used; the size of the repository may '
-'significantly')))
+'shrink significantly when there are many merges; this '
+'optimization will slow down execution in proportion to '
-optimizations.append(improvement(
+'the number of merges in the repository and the amount '
-name='re-delta-all',
+'of files in the repository; this slow down should not '
-type=optimisation,
+'be significant unless there are tens of thousands of '
-description=_('deltas within internal storage will always be '
+'files and thousands of merges'
-'recalculated without reusing prior deltas; this will '
+),
-'likely make execution run several times slower; this '
+upgrademessage=_(
-'optimization is typically not needed'),
+'deltas within internal storage will choose an '
-upgrademessage=_('deltas within internal storage will be fully '
+'optimal delta by computing deltas against multiple '
-'recomputed; this will likely drastically slow down '
+'parents; may slow down execution time '
-'execution time')))
+'significantly'
+),
-optimizations.append(improvement(
+)
-name='re-delta-fulladd',
+)
-type=optimisation,
-description=_('every revision will be re-added as if it was new '
+optimizations.append(
-'content. It will go through the full storage '
+improvement(
-'mechanism giving extensions a chance to process it '
+name='re-delta-all',
-'(eg. lfs). This is similar to "re-delta-all" but even '
+type=optimisation,
-'slower since more logic is involved.'),
+description=_(
-upgrademessage=_('each revision will be added as new content to the '
+'deltas within internal storage will always be '
-'internal storage; this will likely drastically slow '
+'recalculated without reusing prior deltas; this will '
-'down execution time, but some extensions might need '
+'likely make execution run several times slower; this '
-'it')))
+'optimization is typically not needed'
+),
+upgrademessage=_(
+'deltas within internal storage will be fully '
+'recomputed; this will likely drastically slow down '
+'execution time'
+),
+)
+)
+optimizations.append(
+improvement(
+name='re-delta-fulladd',
+type=optimisation,
+description=_(
+'every revision will be re-added as if it was new '
+'content. It will go through the full storage '
+'mechanism giving extensions a chance to process it '
+'(eg. lfs). This is similar to "re-delta-all" but even '
+'slower since more logic is involved.'
+),
+upgrademessage=_(
+'each revision will be added as new content to the '
+'internal storage; this will likely drastically slow '
+'down execution time, but some extensions might need '
+'it'
+),
+)
+)
 return optimizations
 def determineactions(repo, deficiencies, sourcereqs, destreqs):
 """Determine upgrade actions that will be performed.
 Given a list of improvements as returned by ``finddeficiencies`` and
 # 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')]
+mandir = path[: -len('00manifest.i')]
 return manifest.manifestrevlog(repo.svfs, tree=mandir)
 else:
-#reverse of "/".join(("data", path + ".i"))
+# reverse of "/".join(("data", path + ".i"))
 return filelog.filelog(repo.svfs, path[5:-2])
 def _copyrevlog(tr, destrepo, oldrl, unencodedname):
 """copy all relevant files for `oldrl` into `destrepo` store
 Files are copied "as is" without any transformation. The copy is performed
 newindex = newvfs.join(newrl.indexfile)
 olddata = oldvfs.join(oldrl.datafile)
 newdata = newvfs.join(newrl.datafile)
 with newvfs(newrl.indexfile, 'w'):
-pass # create all the directories
+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')
+if not (
-or unencodedname.endswith('00manifest.i')):
+unencodedname.endswith('00changelog.i')
+or unencodedname.endswith('00manifest.i')
+):
 destrepo.svfs.fncache.add(unencodedname)
 if copydata:
 destrepo.svfs.fncache.add(unencodedname[:-2] + '.d')
 UPGRADE_CHANGELOG = object()
 UPGRADE_MANIFEST = object()
 UPGRADE_FILELOG = object()
-UPGRADE_ALL_REVLOGS = frozenset([UPGRADE_CHANGELOG,
+UPGRADE_ALL_REVLOGS = frozenset(
-UPGRADE_MANIFEST,
+[UPGRADE_CHANGELOG, UPGRADE_MANIFEST, UPGRADE_FILELOG]
-UPGRADE_FILELOG])
+)
 def matchrevlog(revlogfilter, entry):
 """check is a revlog is selected for cloning
 The store entry is checked against the passed filter"""
 return UPGRADE_CHANGELOG in revlogfilter
 elif entry.endswith('00manifest.i'):
 return UPGRADE_MANIFEST in revlogfilter
 return UPGRADE_FILELOG in revlogfilter
-def _clonerevlogs(ui, srcrepo, dstrepo, tr, deltareuse, forcedeltabothparents,
-revlogs=UPGRADE_ALL_REVLOGS):
+def _clonerevlogs(
+ui,
+srcrepo,
+dstrepo,
+tr,
+deltareuse,
+forcedeltabothparents,
+revlogs=UPGRADE_ALL_REVLOGS,
+):
 """Copy revlogs between 2 repos."""
 revcount = 0
 srcsize = 0
 srcrawsize = 0
 dstsize = 0
 if unencoded.endswith('.d'):
 continue
 rl = _revlogfrompath(srcrepo, unencoded)
-info = rl.storageinfo(exclusivefiles=True, revisionscount=True,
+info = rl.storageinfo(
-trackedsize=True, storedsize=True)
+exclusivefiles=True,
+revisionscount=True,
+trackedsize=True,
+storedsize=True,
+)
 revcount += info['revisionscount'] or 0
 datasize = info['storedsize'] or 0
 rawsize = info['trackedsize'] or 0
 error.ProgrammingError('unknown revlog type')
 if not revcount:
 return
-ui.write(_('migrating %d total revisions (%d in filelogs, %d in manifests, '
+ui.write(
-'%d in changelog)\n') %
+_(
-(revcount, frevcount, mrevcount, crevcount))
+'migrating %d total revisions (%d in filelogs, %d in manifests, '
-ui.write(_('migrating %s in store; %s tracked data\n') % (
+'%d in changelog)\n'
-(util.bytecount(srcsize), util.bytecount(srcrawsize))))
+)
+% (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 = None
 def oncopiedrevision(rl, rev, node):
 progress.increment()
 # Do the actual copying.
 # FUTURE this operation can be farmed off to worker processes.
 continue
 oldrl = _revlogfrompath(srcrepo, unencoded)
 if isinstance(oldrl, changelog.changelog) and 'c' not in seen:
-ui.write(_('finished migrating %d manifest revisions across %d '
+ui.write(
-'manifests; change in size: %s\n') %
+_(
-(mrevcount, mcount, util.bytecount(mdstsize - msrcsize)))
+'finished migrating %d manifest revisions across %d '
+'manifests; change in size: %s\n'
-ui.write(_('migrating changelog containing %d revisions '
+)
-'(%s in store; %s tracked data)\n') %
+% (mrevcount, mcount, util.bytecount(mdstsize - msrcsize))
-(crevcount, util.bytecount(csrcsize),
+)
-util.bytecount(crawsize)))
+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 = srcrepo.ui.makeprogress(_('changelog revisions'),
+progress = srcrepo.ui.makeprogress(
-total=crevcount)
+_('changelog revisions'), total=crevcount
+)
 elif isinstance(oldrl, manifest.manifestrevlog) and 'm' not in seen:
-ui.write(_('finished migrating %d filelog revisions across %d '
+ui.write(
-'filelogs; change in size: %s\n') %
+_(
-(frevcount, fcount, util.bytecount(fdstsize - fsrcsize)))
+'finished migrating %d filelog revisions across %d '
+'filelogs; change in size: %s\n'
-ui.write(_('migrating %d manifests containing %d revisions '
+)
-'(%s in store; %s tracked data)\n') %
+% (frevcount, fcount, util.bytecount(fdstsize - fsrcsize))
-(mcount, mrevcount, util.bytecount(msrcsize),
+)
-util.bytecount(mrawsize)))
+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')
 if progress:
 progress.complete()
-progress = srcrepo.ui.makeprogress(_('manifest revisions'),
+progress = srcrepo.ui.makeprogress(
-total=mrevcount)
+_('manifest revisions'), total=mrevcount
+)
 elif 'f' not in seen:
-ui.write(_('migrating %d filelogs containing %d revisions '
+ui.write(
-'(%s in store; %s tracked data)\n') %
+_(
-(fcount, frevcount, util.bytecount(fsrcsize),
+'migrating %d filelogs containing %d revisions '
-util.bytecount(frawsize)))
+'(%s in store; %s tracked data)\n'
+)
+% (
+fcount,
+frevcount,
+util.bytecount(fsrcsize),
+util.bytecount(frawsize),
+)
+)
 seen.add('f')
 if progress:
 progress.complete()
-progress = srcrepo.ui.makeprogress(_('file revisions'),
+progress = srcrepo.ui.makeprogress(
-total=frevcount)
+_('file revisions'), total=frevcount
+)
 if matchrevlog(revlogs, unencoded):
-ui.note(_('cloning %d revisions from %s\n')
+ui.note(
-% (len(oldrl), unencoded))
+_('cloning %d revisions from %s\n') % (len(oldrl), unencoded)
+)
 newrl = _revlogfrompath(dstrepo, unencoded)
-oldrl.clone(tr, newrl, addrevisioncb=oncopiedrevision,
+oldrl.clone(
-deltareuse=deltareuse,
+tr,
-forcedeltabothparents=forcedeltabothparents)
+newrl,
+addrevisioncb=oncopiedrevision,
+deltareuse=deltareuse,
+forcedeltabothparents=forcedeltabothparents,
+)
 else:
 msg = _('blindly copying %s containing %i revisions\n')
 ui.note(msg % (unencoded, len(oldrl)))
 _copyrevlog(tr, dstrepo, oldrl, unencoded)
 else:
 fdstsize += datasize
 progress.complete()
-ui.write(_('finished migrating %d changelog revisions; change in size: '
+ui.write(
-'%s\n') % (crevcount, util.bytecount(cdstsize - csrcsize)))
+_('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)))
+ui.write(
+_(
+'finished migrating %d total revisions; total change in store '
+'size: %s\n'
+)
+% (revcount, util.bytecount(dstsize - srcsize))
+)
 def _filterstorefile(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
 if path in ('lock', 'fncache'):
 return False
 return True
 def _finishdatamigration(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,
-revlogs=UPGRADE_ALL_REVLOGS):
+def _upgraderepo(
+ui, srcrepo, dstrepo, requirements, actions, revlogs=UPGRADE_ALL_REVLOGS
+):
 """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.
 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 '
+ui.write(
-'data migration completes)\n'))
+_(
+'(it is safe to interrupt this process any time before '
+'data migration completes)\n'
+)
+)
 if 're-delta-all' in actions:
 deltareuse = revlog.revlog.DELTAREUSENEVER
 elif 're-delta-parent' in actions:
 deltareuse = revlog.revlog.DELTAREUSESAMEREVS
 deltareuse = revlog.revlog.DELTAREUSEFULLADD
 else:
 deltareuse = revlog.revlog.DELTAREUSEALWAYS
 with dstrepo.transaction('upgrade') as tr:
-_clonerevlogs(ui, srcrepo, dstrepo, tr, deltareuse,
+_clonerevlogs(
-'re-delta-multibase' in actions, revlogs=revlogs)
+ui,
+srcrepo,
+dstrepo,
+tr,
+deltareuse,
+'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)):
-if not _filterstorefile(srcrepo, dstrepo, requirements,
+if not _filterstorefile(srcrepo, dstrepo, requirements, p, kind, st):
-p, kind, st):
 continue
 srcrepo.ui.write(_('copying %s\n') % p)
 src = srcrepo.store.rawvfs.join(p)
 dst = dstrepo.store.rawvfs.join(p)
 # 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 '
+ui.write(
-'unable to read from repository\n'))
+_(
-scmutil.writerequires(srcrepo.vfs,
+'marking source repository as being upgraded; clients will be '
-srcrepo.requirements | {'upgradeinprogress'})
+'unable to read from repository\n'
+)
+)
+scmutil.writerequires(
+srcrepo.vfs, srcrepo.requirements | {'upgradeinprogress'}
+)
 ui.write(_('starting in-place swap of repository data\n'))
-ui.write(_('replaced files will be backed up at %s\n') %
+ui.write(_('replaced files will be backed up at %s\n') % backuppath)
-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 '
+ui.write(
-'%0.1fs\n') % elapsed)
+_(
+'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 '
+ui.write(
-'again\n'))
+_(
+'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, backup=True,
-manifest=None, changelog=None):
+def upgraderepo(
+ui,
+repo,
+run=False,
+optimize=None,
+backup=True,
+manifest=None,
+changelog=None,
+):
 """Upgrade a repository in place."""
 if optimize is None:
 optimize = []
 optimize = set(legacy_opts_map.get(o, o) for o in optimize)
 repo = repo.unfiltered()
 revlogs.discard(UPGRADE_MANIFEST)
 # Ensure the repository can be upgraded.
 missingreqs = requiredsourcerequirements(repo) - repo.requirements
 if missingreqs:
-raise error.Abort(_('cannot upgrade repository; requirement '
+raise error.Abort(
-'missing: %s') % _(', ').join(sorted(missingreqs)))
+_('cannot upgrade repository; requirement ' 'missing: %s')
+% _(', ').join(sorted(missingreqs))
+)
 blockedreqs = blocksourcerequirements(repo) & repo.requirements
 if blockedreqs:
-raise error.Abort(_('cannot upgrade repository; unsupported source '
+raise error.Abort(
-'requirement: %s') %
+_(
-_(', ').join(sorted(blockedreqs)))
+'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.ui, localrepo.defaultcreateopts(repo.ui))
+repo.ui, localrepo.defaultcreateopts(repo.ui)
+)
 newreqs.update(preservedrequirements(repo))
-noremovereqs = (repo.requirements - newreqs -
+noremovereqs = (
-supportremovedrequirements(repo))
+repo.requirements - newreqs - supportremovedrequirements(repo)
+)
 if noremovereqs:
-raise error.Abort(_('cannot upgrade repository; requirement would be '
+raise error.Abort(
-'removed: %s') % _(', ').join(sorted(noremovereqs)))
+_('cannot upgrade repository; requirement would be ' 'removed: %s')
+% _(', ').join(sorted(noremovereqs))
-noaddreqs = (newreqs - repo.requirements -
+)
-allowednewrequirements(repo))
+noaddreqs = newreqs - repo.requirements - allowednewrequirements(repo)
 if noaddreqs:
-raise error.Abort(_('cannot upgrade repository; do not support adding '
+raise error.Abort(
-'requirement: %s') %
+_(
-_(', ').join(sorted(noaddreqs)))
+'cannot upgrade repository; do not support adding '
+'requirement: %s'
+)
+% _(', ').join(sorted(noaddreqs))
+)
 unsupportedreqs = newreqs - supporteddestrequirements(repo)
 if unsupportedreqs:
-raise error.Abort(_('cannot upgrade repository; do not support '
+raise error.Abort(
-'destination requirement: %s') %
+_(
-_(', ').join(sorted(unsupportedreqs)))
+'cannot upgrade repository; do not support '
+'destination requirement: %s'
+)
+% _(', ').join(sorted(unsupportedreqs))
+)
 # Find and validate all improvements that can be made.
 alloptimizations = findoptimizations(repo)
 # Apply and Validate arguments.
 for o in alloptimizations:
 if o.name in optimize:
 optimizations.append(o)
 optimize.discard(o.name)
-if optimize: # anything left is unknown
+if optimize:  # anything left is unknown
-raise error.Abort(_('unknown optimization action requested: %s') %
+raise error.Abort(
-', '.join(sorted(optimize)),
+_('unknown optimization action requested: %s')
-hint=_('run without arguments to see valid '
+% ', '.join(sorted(optimize)),
-'optimizations'))
+hint=_('run without arguments to see valid ' 'optimizations'),
+)
 deficiencies = finddeficiencies(repo)
 actions = determineactions(repo, deficiencies, repo.requirements, newreqs)
-actions.extend(o for o in sorted(optimizations)
+actions.extend(
-# determineactions could have added optimisation
+o
-if o not in actions)
+for o in sorted(optimizations)
+# determineactions could have added optimisation
+if o not in actions
+)
 removedreqs = repo.requirements - newreqs
 addedreqs = newreqs - repo.requirements
 if revlogs != UPGRADE_ALL_REVLOGS:
 incompatible = RECLONES_REQUIREMENTS & (removedreqs | addedreqs)
 if incompatible:
-msg = _('ignoring revlogs selection flags, format requirements '
+msg = _(
-'change: %s\n')
+'ignoring revlogs selection flags, format requirements '
+'change: %s\n'
+)
 ui.warn(msg % ', '.join(sorted(incompatible)))
 revlogs = UPGRADE_ALL_REVLOGS
 def printrequirements():
 ui.write(_('requirements\n'))
-ui.write(_('   preserved: %s\n') %
+ui.write(
-_(', ').join(sorted(newreqs & repo.requirements)))
+_('   preserved: %s\n')
+% _(', ').join(sorted(newreqs & repo.requirements))
+)
 if repo.requirements - newreqs:
-ui.write(_('   removed: %s\n') %
+ui.write(
-_(', ').join(sorted(repo.requirements - newreqs)))
+_('   removed: %s\n')
+% _(', ').join(sorted(repo.requirements - newreqs))
+)
 if newreqs - repo.requirements:
-ui.write(_('   added: %s\n') %
+ui.write(
-_(', ').join(sorted(newreqs - repo.requirements)))
+_('   added: %s\n')
+% _(', ').join(sorted(newreqs - repo.requirements))
+)
 ui.write('\n')
 def printupgradeactions():
 for a in actions:
 onlydefault.append(d)
 if fromconfig or onlydefault:
 if fromconfig:
-ui.write(_('repository lacks features recommended by '
+ui.write(
-'current config options:\n\n'))
+_(
+'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 '
+ui.write(
-'config options:\n\n'))
+_(
+'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 '
+ui.write(
-'repository)\n'))
+_('(no feature deficiencies found in existing ' 'repository)\n')
+)
-ui.write(_('performing an upgrade with "--run" will make the following '
-'changes:\n\n'))
+ui.write(
+_(
+'performing an upgrade with "--run" will make the following '
+'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 '
+ui.write(
-'"--optimize <name>":\n\n'))
+_(
+'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.
 # to create a new repo object than to instantiate all the components
 # (like the store) separately.
 tmppath = pycompat.mkdtemp(prefix='upgrade.', dir=repo.path)
 backuppath = None
 try:
-ui.write(_('creating temporary repository to stage migrated '
+ui.write(
-'data: %s\n') % tmppath)
+_(
+'creating temporary repository to stage migrated '
+'data: %s\n'
+)
+% tmppath
+)
 # clone ui without using ui.copy because repo.ui is protected
 repoui = repo.ui.__class__(repo.ui)
 dstrepo = hg.repository(repoui, path=tmppath, create=True)
 with dstrepo.wlock(), dstrepo.lock():
-backuppath = _upgraderepo(ui, repo, dstrepo, newreqs,
+backuppath = _upgraderepo(
-upgradeactions, revlogs=revlogs)
+ui, repo, dstrepo, newreqs, upgradeactions, revlogs=revlogs
+)
 if not (backup or backuppath is None):
 ui.write(_('removing old repository content%s\n') % backuppath)
 repo.vfs.rmtree(backuppath, forcibly=True)
 backuppath = None
 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') %
+ui.warn(
-backuppath)
+_('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 '
+ui.warn(
-'repository is verified\n'))
+_(
+'the old repository will not be deleted; remove '
+'it to free up disk space once the upgraded '
+'repository is verified\n'
+)
+)

changeset 43076	2372284d9457
parent 43031	e16ca9fde7aa
child 43077	687b865b95ad