upgrade.py
1012 lines
| 31.2 KiB
| text/x-python
|
PythonLexer
/ mercurial / upgrade.py
|
r31894 | # upgrade.py - functions for in place upgrade of Mercurial repository | ||
|
r31864 | # | ||
|
r31895 | # Copyright (c) 2016-present, Gregory Szorc | ||
|
r31864 | # | ||
# 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 | ||||
from .i18n import _ | ||||
from . import ( | ||||
error, | ||||
|
r35344 | hg, | ||
|
r31893 | localrepo, | ||
|
r38183 | pycompat, | ||
|
r45932 | requirements, | ||
|
r31864 | util, | ||
r46661 | ) | |||
from .upgrade_utils import ( | ||||
engine as upgrade_engine, | ||||
|
r31864 | ) | ||
|
r43346 | from .utils import compression | ||
r42306 | ||||
r43100 | # list of requirements that request a clone of all revlog if added/removed | |||
RECLONES_REQUIREMENTS = { | ||||
|
r43347 | b'generaldelta', | ||
|
r45933 | requirements.SPARSEREVLOG_REQUIREMENT, | ||
r43100 | } | |||
|
r43346 | |||
|
r31865 | def requiredsourcerequirements(repo): | ||
|
r31864 | """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. | ||||
""" | ||||
|
r32291 | return { | ||
|
r31864 | # Introduced in Mercurial 0.9.2. | ||
|
r43347 | b'revlogv1', | ||
|
r31864 | # Introduced in Mercurial 0.9.2. | ||
|
r43347 | b'store', | ||
|
r32291 | } | ||
|
r31864 | |||
|
r43346 | |||
|
r31866 | def blocksourcerequirements(repo): | ||
|
r31864 | """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. | ||||
""" | ||||
|
r32291 | return { | ||
|
r31864 | # The upgrade code does not yet support these experimental features. | ||
# This is an artificial limitation. | ||||
|
r45932 | requirements.TREEMANIFEST_REQUIREMENT, | ||
|
r31864 | # This was a precursor to generaldelta and was never enabled by default. | ||
# It should (hopefully) not exist in the wild. | ||||
|
r43347 | b'parentdelta', | ||
|
r31864 | # Upgrade should operate on the actual store, not the shared link. | ||
|
r45946 | requirements.SHARED_REQUIREMENT, | ||
|
r32291 | } | ||
|
r31864 | |||
|
r43346 | |||
|
r31867 | def supportremovedrequirements(repo): | ||
|
r31864 | """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. | ||||
""" | ||||
r42306 | supported = { | |||
|
r45933 | requirements.SPARSEREVLOG_REQUIREMENT, | ||
requirements.SIDEDATA_REQUIREMENT, | ||||
requirements.COPIESSDC_REQUIREMENT, | ||||
requirements.NODEMAP_REQUIREMENT, | ||||
|
r46618 | requirements.SHARESAFE_REQUIREMENT, | ||
|
r38742 | } | ||
r42306 | for name in compression.compengines: | |||
engine = compression.compengines[name] | ||||
if engine.available() and engine.revlogheader(): | ||||
supported.add(b'exp-compression-%s' % name) | ||||
|
r43347 | if engine.name() == b'zstd': | ||
r42306 | supported.add(b'revlog-compression-zstd') | |||
return supported | ||||
|
r31864 | |||
|
r43346 | |||
|
r31870 | def supporteddestrequirements(repo): | ||
|
r31864 | """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. | ||||
""" | ||||
r42306 | supported = { | |||
|
r43347 | b'dotencode', | ||
b'fncache', | ||||
b'generaldelta', | ||||
b'revlogv1', | ||||
b'store', | ||||
|
r45933 | requirements.SPARSEREVLOG_REQUIREMENT, | ||
requirements.SIDEDATA_REQUIREMENT, | ||||
requirements.COPIESSDC_REQUIREMENT, | ||||
requirements.NODEMAP_REQUIREMENT, | ||||
|
r46059 | requirements.SHARESAFE_REQUIREMENT, | ||
|
r32291 | } | ||
r42306 | for name in compression.compengines: | |||
engine = compression.compengines[name] | ||||
if engine.available() and engine.revlogheader(): | ||||
supported.add(b'exp-compression-%s' % name) | ||||
|
r43347 | if engine.name() == b'zstd': | ||
r42306 | supported.add(b'revlog-compression-zstd') | |||
return supported | ||||
|
r31864 | |||
|
r43346 | |||
|
r31869 | def allowednewrequirements(repo): | ||
|
r31864 | """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. | ||||
""" | ||||
r42306 | supported = { | |||
|
r43347 | b'dotencode', | ||
b'fncache', | ||||
b'generaldelta', | ||||
|
r45933 | requirements.SPARSEREVLOG_REQUIREMENT, | ||
requirements.SIDEDATA_REQUIREMENT, | ||||
requirements.COPIESSDC_REQUIREMENT, | ||||
requirements.NODEMAP_REQUIREMENT, | ||||
|
r46617 | requirements.SHARESAFE_REQUIREMENT, | ||
|
r32291 | } | ||
r42306 | for name in compression.compengines: | |||
engine = compression.compengines[name] | ||||
if engine.available() and engine.revlogheader(): | ||||
supported.add(b'exp-compression-%s' % name) | ||||
|
r43347 | if engine.name() == b'zstd': | ||
r42306 | supported.add(b'revlog-compression-zstd') | |||
return supported | ||||
|
r31864 | |||
|
r43346 | |||
|
r35303 | def preservedrequirements(repo): | ||
return set() | ||||
|
r43346 | |||
r46608 | DEFICIENCY = b'deficiency' | |||
r46609 | OPTIMISATION = b'optimization' | |||
|
r31864 | |||
|
r43346 | |||
|
r31868 | class improvement(object): | ||
|
r31864 | """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 | ||||
r46609 | Either ``DEFICIENCY`` or ``OPTIMISATION``. A deficiency is an obvious | |||
|
r31864 | 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, | ||||
r46608 | including the implications of it. For ``DEFICIENCY`` types, should be | |||
r46609 | worded in the present tense. For ``OPTIMISATION`` types, should be | |||
|
r31864 | 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. | ||||
""" | ||||
|
r43346 | |||
|
r32030 | def __init__(self, name, type, description, upgrademessage): | ||
|
r31864 | self.name = name | ||
self.type = type | ||||
self.description = description | ||||
self.upgrademessage = upgrademessage | ||||
|
r31902 | def __eq__(self, other): | ||
if not isinstance(other, improvement): | ||||
# This is what python tell use to do | ||||
return NotImplemented | ||||
return self.name == other.name | ||||
|
r32028 | def __ne__(self, other): | ||
|
r41033 | return not (self == other) | ||
|
r32028 | |||
|
r32029 | def __hash__(self): | ||
return hash(self.name) | ||||
|
r43346 | |||
|
r32032 | allformatvariant = [] | ||
|
r43346 | |||
|
r32032 | def registerformatvariant(cls): | ||
allformatvariant.append(cls) | ||||
return cls | ||||
|
r43346 | |||
|
r32030 | class formatvariant(improvement): | ||
|
r32031 | """an improvement subclass dedicated to repository format""" | ||
|
r43346 | |||
r46608 | type = DEFICIENCY | |||
|
r32031 | ### 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. | ||||
name = None | ||||
|
r32030 | |||
|
r32031 | # message intended for humans explaining the improvement in more detail, | ||
r46608 | # including the implications of it ``DEFICIENCY`` types, should be worded | |||
|
r32031 | # in the present tense. | ||
description = None | ||||
# message intended for humans explaining what an upgrade addressing this | ||||
# issue will do. should be worded in the future tense. | ||||
upgrademessage = None | ||||
|
r32030 | |||
|
r32031 | # value of current Mercurial default for new repository | ||
default = None | ||||
def __init__(self): | ||||
raise NotImplementedError() | ||||
@staticmethod | ||||
def fromrepo(repo): | ||||
"""current value of the variant in the repository""" | ||||
raise NotImplementedError() | ||||
|
r32030 | |||
|
r32031 | @staticmethod | ||
def fromconfig(repo): | ||||
"""current value of the variant in the configuration""" | ||||
raise NotImplementedError() | ||||
|
r43346 | |||
|
r32031 | 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. | ||||
|
r32030 | """ | ||
|
r32031 | # the requirement that control this format variant | ||
_requirement = None | ||||
@staticmethod | ||||
|
r39583 | def _newreporequirements(ui): | ||
|
r40032 | return localrepo.newreporequirements( | ||
|
r43346 | ui, localrepo.defaultcreateopts(ui) | ||
) | ||||
|
r32031 | |||
@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 | ||||
|
r39583 | return cls._requirement in cls._newreporequirements(repo.ui) | ||
|
r32031 | |||
|
r43346 | |||
|
r32032 | @registerformatvariant | ||
|
r32031 | class fncache(requirementformatvariant): | ||
|
r43347 | name = b'fncache' | ||
|
r32031 | |||
|
r43347 | _requirement = b'fncache' | ||
|
r32031 | |||
default = True | ||||
|
r43346 | description = _( | ||
|
r43347 | b'long and reserved filenames may not work correctly; ' | ||
b'repository performance is sub-optimal' | ||||
|
r43346 | ) | ||
|
r32031 | |||
|
r43346 | upgrademessage = _( | ||
|
r43347 | b'repository will be more resilient to storing ' | ||
b'certain paths and performance of certain ' | ||||
b'operations should be improved' | ||||
|
r43346 | ) | ||
|
r32031 | |||
|
r32032 | @registerformatvariant | ||
|
r32031 | class dotencode(requirementformatvariant): | ||
|
r43347 | name = b'dotencode' | ||
|
r32031 | |||
|
r43347 | _requirement = b'dotencode' | ||
|
r32031 | |||
default = True | ||||
|
r43346 | description = _( | ||
|
r43347 | b'storage of filenames beginning with a period or ' | ||
b'space may not work correctly' | ||||
|
r43346 | ) | ||
|
r32031 | |||
|
r43346 | upgrademessage = _( | ||
|
r43347 | b'repository will be better able to store files ' | ||
b'beginning with a space or period' | ||||
|
r43346 | ) | ||
|
r32031 | |||
|
r32032 | @registerformatvariant | ||
|
r32031 | class generaldelta(requirementformatvariant): | ||
|
r43347 | name = b'generaldelta' | ||
|
r32031 | |||
|
r43347 | _requirement = b'generaldelta' | ||
|
r32031 | |||
default = True | ||||
|
r43346 | description = _( | ||
|
r43347 | b'deltas within internal storage are unable to ' | ||
b'choose optimal revisions; repository is larger and ' | ||||
b'slower than it could be; interaction with other ' | ||||
b'repositories may require extra network and CPU ' | ||||
b'resources, making "hg push" and "hg pull" slower' | ||||
|
r43346 | ) | ||
|
r32031 | |||
|
r43346 | upgrademessage = _( | ||
|
r43347 | b'repository storage will be able to create ' | ||
b'optimal deltas; new repository data will be ' | ||||
b'smaller and read times should decrease; ' | ||||
b'interacting with other repositories using this ' | ||||
b'storage model should require less network and ' | ||||
b'CPU resources, making "hg push" and "hg pull" ' | ||||
b'faster' | ||||
|
r43346 | ) | ||
|
r32031 | |||
|
r32032 | @registerformatvariant | ||
|
r46617 | class sharedsafe(requirementformatvariant): | ||
name = b'exp-sharesafe' | ||||
_requirement = requirements.SHARESAFE_REQUIREMENT | ||||
default = False | ||||
description = _( | ||||
b'old shared repositories do not share source repository ' | ||||
b'requirements and config. This leads to various problems ' | ||||
b'when the source repository format is upgraded or some new ' | ||||
b'extensions are enabled.' | ||||
) | ||||
upgrademessage = _( | ||||
b'Upgrades a repository to share-safe format so that future ' | ||||
b'shares of this repository share its requirements and configs.' | ||||
) | ||||
@registerformatvariant | ||||
|
r38741 | class sparserevlog(requirementformatvariant): | ||
|
r43347 | name = b'sparserevlog' | ||
|
r38741 | |||
|
r45933 | _requirement = requirements.SPARSEREVLOG_REQUIREMENT | ||
|
r38741 | |||
|
r40954 | default = True | ||
|
r38741 | |||
|
r43346 | description = _( | ||
|
r43347 | b'in order to limit disk reading and memory usage on older ' | ||
b'version, the span of a delta chain from its root to its ' | ||||
b'end is limited, whatever the relevant data in this span. ' | ||||
b'This can severly limit Mercurial ability to build good ' | ||||
b'chain of delta resulting is much more storage space being ' | ||||
b'taken and limit reusability of on disk delta during ' | ||||
b'exchange.' | ||||
|
r43346 | ) | ||
|
r38741 | |||
|
r43346 | upgrademessage = _( | ||
|
r43347 | b'Revlog supports delta chain with more unused data ' | ||
b'between payload. These gaps will be skipped at read ' | ||||
b'time. This allows for better delta chains, making a ' | ||||
b'better compression and faster exchange with server.' | ||||
|
r43346 | ) | ||
|
r38741 | |||
@registerformatvariant | ||||
r43299 | class sidedata(requirementformatvariant): | |||
|
r43347 | name = b'sidedata' | ||
r43299 | ||||
|
r45933 | _requirement = requirements.SIDEDATA_REQUIREMENT | ||
r43299 | ||||
default = False | ||||
|
r43346 | description = _( | ||
|
r43347 | b'Allows storage of extra data alongside a revision, ' | ||
b'unlocking various caching options.' | ||||
|
r43346 | ) | ||
r43299 | ||||
|
r43347 | upgrademessage = _(b'Allows storage of extra data alongside a revision.') | ||
r43299 | ||||
|
r43346 | |||
r43299 | @registerformatvariant | |||
r45303 | class persistentnodemap(requirementformatvariant): | |||
name = b'persistent-nodemap' | ||||
|
r45933 | _requirement = requirements.NODEMAP_REQUIREMENT | ||
r45303 | ||||
default = False | ||||
description = _( | ||||
b'persist the node -> rev mapping on disk to speedup lookup' | ||||
) | ||||
upgrademessage = _(b'Speedup revision lookup by node id.') | ||||
@registerformatvariant | ||||
r43408 | class copiessdc(requirementformatvariant): | |||
name = b'copies-sdc' | ||||
|
r45933 | _requirement = requirements.COPIESSDC_REQUIREMENT | ||
r43408 | ||||
default = False | ||||
description = _(b'Stores copies information alongside changesets.') | ||||
upgrademessage = _( | ||||
b'Allows to use more efficient algorithm to deal with ' b'copy tracing.' | ||||
) | ||||
@registerformatvariant | ||||
|
r32031 | class removecldeltachain(formatvariant): | ||
|
r43347 | name = b'plain-cl-delta' | ||
|
r32031 | |||
default = True | ||||
|
r43346 | description = _( | ||
|
r43347 | b'changelog storage is using deltas instead of ' | ||
b'raw entries; changelog reading and any ' | ||||
b'operation relying on changelog data are slower ' | ||||
b'than they could be' | ||||
|
r43346 | ) | ||
|
r32031 | |||
|
r43346 | upgrademessage = _( | ||
|
r43347 | b'changelog storage will be reformated to ' | ||
b'store raw entries; changelog reading will be ' | ||||
b'faster; changelog size may be reduced' | ||||
|
r43346 | ) | ||
|
r32031 | |||
@staticmethod | ||||
def fromrepo(repo): | ||||
# Mercurial 4.0 changed changelogs to not use delta chains. Search for | ||||
# changelogs with deltas. | ||||
cl = repo.changelog | ||||
chainbase = cl.chainbase | ||||
return all(rev == chainbase(rev) for rev in cl) | ||||
@staticmethod | ||||
def fromconfig(repo): | ||||
return True | ||||
|
r32030 | |||
|
r43346 | |||
|
r35341 | @registerformatvariant | ||
class compressionengine(formatvariant): | ||||
|
r43347 | name = b'compression' | ||
default = b'zlib' | ||||
|
r35341 | |||
|
r43346 | description = _( | ||
|
r43347 | b'Compresion algorithm used to compress data. ' | ||
b'Some engine are faster than other' | ||||
|
r43346 | ) | ||
|
r35341 | |||
|
r43346 | upgrademessage = _( | ||
|
r43387 | b'revlog content will be recompressed with the new algorithm.' | ||
|
r43346 | ) | ||
|
r35341 | |||
@classmethod | ||||
def fromrepo(cls, repo): | ||||
r42305 | # 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" | ||||
|
r43347 | compression = b'zlib' | ||
|
r35341 | for req in repo.requirements: | ||
r42305 | prefix = req.startswith | |||
|
r43347 | if prefix(b'revlog-compression-') or prefix(b'exp-compression-'): | ||
compression = req.split(b'-', 2)[2] | ||||
r42305 | return compression | |||
|
r35341 | |||
@classmethod | ||||
def fromconfig(cls, repo): | ||||
r44866 | compengines = repo.ui.configlist(b'format', b'revlog-compression') | |||
# return the first valid value as the selection code would do | ||||
for comp in compengines: | ||||
if comp in util.compengines: | ||||
return comp | ||||
# no valide compression found lets display it all for clarity | ||||
return b','.join(compengines) | ||||
|
r35341 | |||
|
r43346 | |||
r42212 | @registerformatvariant | |||
class compressionlevel(formatvariant): | ||||
|
r43347 | name = b'compression-level' | ||
default = b'default' | ||||
r42212 | ||||
|
r43347 | description = _(b'compression level') | ||
r42212 | ||||
|
r43347 | upgrademessage = _(b'revlog content will be recompressed') | ||
r42212 | ||||
@classmethod | ||||
def fromrepo(cls, repo): | ||||
comp = compressionengine.fromrepo(repo) | ||||
level = None | ||||
|
r43347 | if comp == b'zlib': | ||
level = repo.ui.configint(b'storage', b'revlog.zlib.level') | ||||
elif comp == b'zstd': | ||||
level = repo.ui.configint(b'storage', b'revlog.zstd.level') | ||||
r42212 | if level is None: | |||
|
r43347 | return b'default' | ||
r42212 | return bytes(level) | |||
@classmethod | ||||
def fromconfig(cls, repo): | ||||
comp = compressionengine.fromconfig(repo) | ||||
level = None | ||||
|
r43347 | if comp == b'zlib': | ||
level = repo.ui.configint(b'storage', b'revlog.zlib.level') | ||||
elif comp == b'zstd': | ||||
level = repo.ui.configint(b'storage', b'revlog.zstd.level') | ||||
r42212 | if level is None: | |||
|
r43347 | return b'default' | ||
r42212 | return bytes(level) | |||
|
r43346 | |||
|
r31896 | def finddeficiencies(repo): | ||
"""returns a list of deficiencies that the repo suffer from""" | ||||
deficiencies = [] | ||||
|
r31864 | |||
# 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. | ||||
|
r32032 | for fv in allformatvariant: | ||
if not fv.fromrepo(repo): | ||||
deficiencies.append(fv) | ||||
|
r31864 | |||
|
r31896 | return deficiencies | ||
|
r31864 | |||
|
r43346 | |||
|
r41120 | # 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 | ||||
# forms in script when comparing result is anoying enough to add | ||||
# backward compatibility for a while. | ||||
legacy_opts_map = { | ||||
|
r43347 | b'redeltaparent': b're-delta-parent', | ||
b'redeltamultibase': b're-delta-multibase', | ||||
b'redeltaall': b're-delta-all', | ||||
b'redeltafulladd': b're-delta-fulladd', | ||||
|
r41120 | } | ||
r46610 | ALL_OPTIMISATIONS = [] | |||
def register_optimization(obj): | ||||
ALL_OPTIMISATIONS.append(obj) | ||||
return obj | ||||
register_optimization( | ||||
improvement( | ||||
name=b're-delta-parent', | ||||
type=OPTIMISATION, | ||||
description=_( | ||||
b'deltas within internal storage will be recalculated to ' | ||||
b'choose an optimal base revision where this was not ' | ||||
b'already done; the size of the repository may shrink and ' | ||||
b'various operations may become faster; the first time ' | ||||
b'this optimization is performed could slow down upgrade ' | ||||
b'execution considerably; subsequent invocations should ' | ||||
b'not run noticeably slower' | ||||
), | ||||
upgrademessage=_( | ||||
b'deltas within internal storage will choose a new ' | ||||
b'base revision if needed' | ||||
), | ||||
) | ||||
) | ||||
register_optimization( | ||||
improvement( | ||||
name=b're-delta-multibase', | ||||
type=OPTIMISATION, | ||||
description=_( | ||||
b'deltas within internal storage will be recalculated ' | ||||
b'against multiple base revision and the smallest ' | ||||
b'difference will be used; the size of the repository may ' | ||||
b'shrink significantly when there are many merges; this ' | ||||
b'optimization will slow down execution in proportion to ' | ||||
b'the number of merges in the repository and the amount ' | ||||
b'of files in the repository; this slow down should not ' | ||||
b'be significant unless there are tens of thousands of ' | ||||
b'files and thousands of merges' | ||||
), | ||||
upgrademessage=_( | ||||
b'deltas within internal storage will choose an ' | ||||
b'optimal delta by computing deltas against multiple ' | ||||
b'parents; may slow down execution time ' | ||||
b'significantly' | ||||
), | ||||
) | ||||
) | ||||
register_optimization( | ||||
improvement( | ||||
name=b're-delta-all', | ||||
type=OPTIMISATION, | ||||
description=_( | ||||
b'deltas within internal storage will always be ' | ||||
b'recalculated without reusing prior deltas; this will ' | ||||
b'likely make execution run several times slower; this ' | ||||
b'optimization is typically not needed' | ||||
), | ||||
upgrademessage=_( | ||||
b'deltas within internal storage will be fully ' | ||||
b'recomputed; this will likely drastically slow down ' | ||||
b'execution time' | ||||
), | ||||
) | ||||
) | ||||
register_optimization( | ||||
improvement( | ||||
name=b're-delta-fulladd', | ||||
type=OPTIMISATION, | ||||
description=_( | ||||
b'every revision will be re-added as if it was new ' | ||||
b'content. It will go through the full storage ' | ||||
b'mechanism giving extensions a chance to process it ' | ||||
b'(eg. lfs). This is similar to "re-delta-all" but even ' | ||||
b'slower since more logic is involved.' | ||||
), | ||||
upgrademessage=_( | ||||
b'each revision will be added as new content to the ' | ||||
b'internal storage; this will likely drastically slow ' | ||||
b'down execution time, but some extensions might need ' | ||||
b'it' | ||||
), | ||||
) | ||||
) | ||||
|
r43346 | |||
|
r31896 | def findoptimizations(repo): | ||
"""Determine optimisation that could be used during upgrade""" | ||||
|
r31864 | # These are unconditionally added. There is logic later that figures out | ||
# which ones to apply. | ||||
r46610 | return list(ALL_OPTIMISATIONS) | |||
|
r31864 | |||
|
r43346 | |||
|
r31900 | def determineactions(repo, deficiencies, sourcereqs, destreqs): | ||
|
r31864 | """Determine upgrade actions that will be performed. | ||
|
r31896 | Given a list of improvements as returned by ``finddeficiencies`` and | ||
``findoptimizations``, determine the list of upgrade actions that | ||||
will be performed. | ||||
|
r31864 | |||
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 = [] | ||||
|
r31900 | for d in deficiencies: | ||
r45248 | name = d._requirement | |||
|
r31864 | |||
# If the action is a requirement that doesn't show up in the | ||||
# destination requirements, prune the action. | ||||
r45248 | if name is not None and name not in destreqs: | |||
|
r31864 | continue | ||
|
r31903 | newactions.append(d) | ||
|
r31864 | |||
# FUTURE consider adding some optimizations here for certain transitions. | ||||
# e.g. adding generaldelta could schedule parent redeltas. | ||||
return newactions | ||||
|
r43346 | |||
def upgraderepo( | ||||
ui, | ||||
repo, | ||||
run=False, | ||||
optimize=None, | ||||
backup=True, | ||||
manifest=None, | ||||
changelog=None, | ||||
r46612 | filelogs=None, | |||
|
r43346 | ): | ||
|
r31864 | """Upgrade a repository in place.""" | ||
|
r41120 | if optimize is None: | ||
optimize = [] | ||||
|
r44937 | optimize = {legacy_opts_map.get(o, o) for o in optimize} | ||
|
r31864 | repo = repo.unfiltered() | ||
r46661 | revlogs = set(upgrade_engine.UPGRADE_ALL_REVLOGS) | |||
r46595 | specentries = ( | |||
r46661 | (upgrade_engine.UPGRADE_CHANGELOG, changelog), | |||
(upgrade_engine.UPGRADE_MANIFEST, manifest), | ||||
(upgrade_engine.UPGRADE_FILELOGS, filelogs), | ||||
r46595 | ) | |||
r43098 | 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() | ||||
r46595 | for upgrade, enabled in specified: | |||
r43098 | if enabled: | |||
r46595 | revlogs.add(upgrade) | |||
r43098 | else: | |||
# none are enabled | ||||
r46595 | for upgrade, __ in specified: | |||
revlogs.discard(upgrade) | ||||
r43098 | ||||
|
r31864 | # Ensure the repository can be upgraded. | ||
|
r31865 | missingreqs = requiredsourcerequirements(repo) - repo.requirements | ||
|
r31864 | if missingreqs: | ||
|
r43346 | raise error.Abort( | ||
|
r43387 | _(b'cannot upgrade repository; requirement missing: %s') | ||
|
r43347 | % _(b', ').join(sorted(missingreqs)) | ||
|
r43346 | ) | ||
|
r31864 | |||
|
r31866 | blockedreqs = blocksourcerequirements(repo) & repo.requirements | ||
|
r31864 | if blockedreqs: | ||
|
r43346 | raise error.Abort( | ||
_( | ||||
|
r43347 | b'cannot upgrade repository; unsupported source ' | ||
b'requirement: %s' | ||||
|
r43346 | ) | ||
|
r43347 | % _(b', ').join(sorted(blockedreqs)) | ||
|
r43346 | ) | ||
|
r31864 | |||
# FUTURE there is potentially a need to control the wanted requirements via | ||||
# command arguments or via an extension hook point. | ||||
|
r40032 | newreqs = localrepo.newreporequirements( | ||
|
r43346 | repo.ui, localrepo.defaultcreateopts(repo.ui) | ||
) | ||||
|
r35303 | newreqs.update(preservedrequirements(repo)) | ||
|
r31864 | |||
|
r43346 | noremovereqs = ( | ||
repo.requirements - newreqs - supportremovedrequirements(repo) | ||||
) | ||||
|
r31864 | if noremovereqs: | ||
|
r43346 | raise error.Abort( | ||
|
r43347 | _( | ||
b'cannot upgrade repository; requirement would be ' | ||||
b'removed: %s' | ||||
) | ||||
% _(b', ').join(sorted(noremovereqs)) | ||||
|
r43346 | ) | ||
|
r31864 | |||
|
r43346 | noaddreqs = newreqs - repo.requirements - allowednewrequirements(repo) | ||
|
r31864 | if noaddreqs: | ||
|
r43346 | raise error.Abort( | ||
_( | ||||
|
r43347 | b'cannot upgrade repository; do not support adding ' | ||
b'requirement: %s' | ||||
|
r43346 | ) | ||
|
r43347 | % _(b', ').join(sorted(noaddreqs)) | ||
|
r43346 | ) | ||
|
r31864 | |||
|
r31870 | unsupportedreqs = newreqs - supporteddestrequirements(repo) | ||
|
r31864 | if unsupportedreqs: | ||
|
r43346 | raise error.Abort( | ||
_( | ||||
|
r43347 | b'cannot upgrade repository; do not support ' | ||
b'destination requirement: %s' | ||||
|
r43346 | ) | ||
|
r43347 | % _(b', ').join(sorted(unsupportedreqs)) | ||
|
r43346 | ) | ||
|
r31864 | |||
# Find and validate all improvements that can be made. | ||||
|
r31899 | alloptimizations = findoptimizations(repo) | ||
|
r31864 | |||
|
r31899 | # Apply and Validate arguments. | ||
optimizations = [] | ||||
for o in alloptimizations: | ||||
if o.name in optimize: | ||||
optimizations.append(o) | ||||
optimize.discard(o.name) | ||||
|
r43346 | if optimize: # anything left is unknown | ||
raise error.Abort( | ||||
|
r43347 | _(b'unknown optimization action requested: %s') | ||
% b', '.join(sorted(optimize)), | ||||
|
r43387 | hint=_(b'run without arguments to see valid optimizations'), | ||
|
r43346 | ) | ||
|
r31864 | |||
|
r31897 | deficiencies = finddeficiencies(repo) | ||
|
r31899 | actions = determineactions(repo, deficiencies, repo.requirements, newreqs) | ||
|
r43346 | actions.extend( | ||
o | ||||
for o in sorted(optimizations) | ||||
# determineactions could have added optimisation | ||||
if o not in actions | ||||
) | ||||
|
r31864 | |||
r43100 | removedreqs = repo.requirements - newreqs | |||
addedreqs = newreqs - repo.requirements | ||||
r46661 | if revlogs != upgrade_engine.UPGRADE_ALL_REVLOGS: | |||
r43100 | incompatible = RECLONES_REQUIREMENTS & (removedreqs | addedreqs) | |||
if incompatible: | ||||
|
r43346 | msg = _( | ||
|
r43347 | b'ignoring revlogs selection flags, format requirements ' | ||
b'change: %s\n' | ||||
|
r43346 | ) | ||
|
r43347 | ui.warn(msg % b', '.join(sorted(incompatible))) | ||
r46661 | revlogs = upgrade_engine.UPGRADE_ALL_REVLOGS | |||
r43100 | ||||
r44257 | def write_labeled(l, label): | |||
first = True | ||||
for r in sorted(l): | ||||
if not first: | ||||
ui.write(b', ') | ||||
ui.write(r, label=label) | ||||
first = False | ||||
|
r31864 | def printrequirements(): | ||
|
r43347 | ui.write(_(b'requirements\n')) | ||
r44257 | ui.write(_(b' preserved: ')) | |||
write_labeled( | ||||
newreqs & repo.requirements, "upgrade-repo.requirement.preserved" | ||||
|
r43346 | ) | ||
r44257 | ui.write((b'\n')) | |||
removed = repo.requirements - newreqs | ||||
|
r31864 | if repo.requirements - newreqs: | ||
r44257 | ui.write(_(b' removed: ')) | |||
write_labeled(removed, "upgrade-repo.requirement.removed") | ||||
ui.write((b'\n')) | ||||
added = newreqs - repo.requirements | ||||
if added: | ||||
ui.write(_(b' added: ')) | ||||
write_labeled(added, "upgrade-repo.requirement.added") | ||||
ui.write((b'\n')) | ||||
|
r43347 | ui.write(b'\n') | ||
|
r31864 | |||
r45301 | def printoptimisations(): | |||
r46609 | optimisations = [a for a in actions if a.type == OPTIMISATION] | |||
r45301 | optimisations.sort(key=lambda a: a.name) | |||
if optimisations: | ||||
ui.write(_(b'optimisations: ')) | ||||
write_labeled( | ||||
[a.name for a in optimisations], | ||||
"upgrade-repo.optimisation.performed", | ||||
) | ||||
ui.write(b'\n\n') | ||||
|
r31864 | def printupgradeactions(): | ||
|
r31903 | for a in actions: | ||
r45302 | ui.status(b'%s\n %s\n\n' % (a.name, a.upgrademessage)) | |||
|
r31864 | |||
r46649 | def print_affected_revlogs(): | |||
if not revlogs: | ||||
ui.write((b'no revlogs to process\n')) | ||||
else: | ||||
ui.write((b'processed revlogs:\n')) | ||||
for r in sorted(revlogs): | ||||
ui.write((b' - %s\n' % r)) | ||||
ui.write((b'\n')) | ||||
|
r31864 | if not run: | ||
fromconfig = [] | ||||
|
r31904 | onlydefault = [] | ||
|
r31864 | |||
|
r31901 | for d in deficiencies: | ||
|
r32031 | if d.fromconfig(repo): | ||
|
r31901 | fromconfig.append(d) | ||
|
r32031 | elif d.default: | ||
|
r31904 | onlydefault.append(d) | ||
|
r31864 | |||
|
r31904 | if fromconfig or onlydefault: | ||
|
r31864 | |||
if fromconfig: | ||||
r45302 | ui.status( | |||
|
r43346 | _( | ||
|
r43347 | b'repository lacks features recommended by ' | ||
b'current config options:\n\n' | ||||
|
r43346 | ) | ||
) | ||||
|
r31864 | for i in fromconfig: | ||
r45302 | ui.status(b'%s\n %s\n\n' % (i.name, i.description)) | |||
|
r31864 | |||
if onlydefault: | ||||
r45302 | ui.status( | |||
|
r43346 | _( | ||
|
r43347 | b'repository lacks features used by the default ' | ||
b'config options:\n\n' | ||||
|
r43346 | ) | ||
) | ||||
|
r31864 | for i in onlydefault: | ||
r45302 | ui.status(b'%s\n %s\n\n' % (i.name, i.description)) | |||
|
r31864 | |||
r45302 | ui.status(b'\n') | |||
|
r31864 | else: | ||
r45302 | ui.status( | |||
|
r43347 | _( | ||
b'(no feature deficiencies found in existing ' | ||||
b'repository)\n' | ||||
) | ||||
|
r43346 | ) | ||
|
r31864 | |||
r45302 | ui.status( | |||
|
r43346 | _( | ||
|
r43347 | b'performing an upgrade with "--run" will make the following ' | ||
b'changes:\n\n' | ||||
|
r43346 | ) | ||
) | ||||
|
r31864 | |||
printrequirements() | ||||
r45301 | printoptimisations() | |||
|
r31864 | printupgradeactions() | ||
r46649 | print_affected_revlogs() | |||
|
r31864 | |||
|
r31903 | unusedoptimize = [i for i in alloptimizations if i not in actions] | ||
|
r31864 | if unusedoptimize: | ||
r45302 | ui.status( | |||
|
r43346 | _( | ||
|
r43347 | b'additional optimizations are available by specifying ' | ||
b'"--optimize <name>":\n\n' | ||||
|
r43346 | ) | ||
) | ||||
|
r31864 | for i in unusedoptimize: | ||
r45302 | ui.status(_(b'%s\n %s\n\n') % (i.name, i.description)) | |||
|
r31864 | return | ||
# Else we're in the run=true case. | ||||
|
r43347 | ui.write(_(b'upgrade will perform the following actions:\n\n')) | ||
|
r31864 | printrequirements() | ||
r45301 | printoptimisations() | |||
|
r31864 | printupgradeactions() | ||
r46649 | print_affected_revlogs() | |||
|
r31864 | |||
|
r31903 | upgradeactions = [a.name for a in actions] | ||
r45302 | ui.status(_(b'beginning upgrade...\n')) | |||
|
r33438 | with repo.wlock(), repo.lock(): | ||
r45302 | ui.status(_(b'repository locked and read-only\n')) | |||
|
r33438 | # 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. | ||||
|
r43347 | tmppath = pycompat.mkdtemp(prefix=b'upgrade.', dir=repo.path) | ||
|
r33438 | backuppath = None | ||
try: | ||||
r45302 | ui.status( | |||
|
r43346 | _( | ||
|
r43347 | b'creating temporary repository to stage migrated ' | ||
b'data: %s\n' | ||||
|
r43346 | ) | ||
% tmppath | ||||
) | ||||
|
r35343 | |||
|
r35380 | # 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) | ||||
|
r31864 | |||
|
r33438 | with dstrepo.wlock(), dstrepo.lock(): | ||
r46661 | backuppath = upgrade_engine.upgrade( | |||
|
r43346 | ui, repo, dstrepo, newreqs, upgradeactions, revlogs=revlogs | ||
) | ||||
|
r41121 | if not (backup or backuppath is None): | ||
r45302 | ui.status( | |||
_(b'removing old repository content%s\n') % backuppath | ||||
) | ||||
|
r41121 | repo.vfs.rmtree(backuppath, forcibly=True) | ||
backuppath = None | ||||
|
r31864 | |||
|
r33438 | finally: | ||
r45302 | ui.status(_(b'removing temporary repository %s\n') % tmppath) | |||
|
r33438 | repo.vfs.rmtree(tmppath, forcibly=True) | ||
|
r31864 | |||
r45302 | if backuppath and not ui.quiet: | |||
|
r43346 | ui.warn( | ||
|
r43347 | _(b'copy of old repository backed up at %s\n') % backuppath | ||
|
r43346 | ) | ||
ui.warn( | ||||
_( | ||||
|
r43347 | b'the old repository will not be deleted; remove ' | ||
b'it to free up disk space once the upgraded ' | ||||
b'repository is verified\n' | ||||
|
r43346 | ) | ||
) | ||||
|
r46617 | |||
if sharedsafe.name in addedreqs: | ||||
ui.warn( | ||||
_( | ||||
b'repository upgraded to share safe mode, existing' | ||||
b' shares will still work in old non-safe mode. ' | ||||
b'Re-share existing shares to use them in safe mode' | ||||
b' New shares will be created in safe mode.\n' | ||||
) | ||||
) | ||||
|
r46618 | if sharedsafe.name in removedreqs: | ||
ui.warn( | ||||
_( | ||||
b'repository downgraded to not use share safe mode, ' | ||||
b'existing shares will not work and needs to' | ||||
b' be reshared.\n' | ||||
) | ||||
) | ||||