This is an archive of the discontinued Mercurial Phabricator instance.

upgrade: rename actions to upgrade_actions
ClosedPublic

Authored by pulkit on Dec 16 2020, 5:14 AM.

Download Raw Diff

Details

Reviewers

marmoute
mharbison72

Group Reviewers

hg-reviewers

Commits

rHG6b40aac4da8e: upgrade: rename actions to upgrade_actions

Summary

The actions were a list of optimizations and format ugrades which will be
upgraded. This does not include things which will be downgraded.

Let's rename the variable for clarity. It now makes obvious that we don't have
any concrete information on what things are downgraded.

Diff Detail

Repository

rHG Mercurial

Branch

default

Lint

No Linters Available

Unit

No Unit Test Coverage

Event Timeline

pulkit created this revision.Dec 16 2020, 5:14 AM

Herald added a reviewer: hg-reviewers. · View Herald TranscriptDec 16 2020, 5:14 AM

Herald added a subscriber: mercurial-patches. · View Herald Transcript

pulkit added a child revision: D9617: debugupgraderepo: minor documentation fix.Dec 16 2020, 5:14 AM

Hum, we don't determine downgrade here ? When do we compute downgrade then ?

okay I see D9618 now. This makes me a bit confuse about the function in the current diff. What is that function about ? do we only use it for display purpose and not behavior purpose ? If so, what do we display during downgrade ?

In D9616#145570, @marmoute wrote:

okay I see D9618 now. This makes me a bit confuse about the function in the current diff. What is that function about ? do we only use it for display purpose and not behavior purpose ? If so, what do we display during downgrade ?

As the diff shows, right now we use it for a couple of purposes:

Display purpose
Checking whether some optimizations exist or not

During downgrade, we display the set of removed requirements.

A good part of the current upgrade code is coupled with diffing old and new requirements which I am planning to refactor in upcoming patches.

pulkit updated this revision to Diff 24545.Dec 30 2020, 5:31 AM

marmoute accepted this revision.Jan 7 2021, 6:59 PM

mharbison72 accepted this revision.Jan 12 2021, 6:45 PM

This revision is now accepted and ready to land.Jan 12 2021, 6:45 PM

pulkit added a commit: rHG6b40aac4da8e: upgrade: rename actions to upgrade_actions.Jan 12 2021, 6:53 PM

Closed by commit rHG6b40aac4da8e: upgrade: rename actions to upgrade_actions (authored by pulkit). · Explain Why

This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

			Path	Packages
M			mercurial/upgrade.py (4 lines)
M			mercurial/upgrade_utils/actions.py (21 lines)
M			mercurial/upgrade_utils/engine.py (10 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	24302		Dec 16 2020, 5:14 AM	★	★
Diff 2	24545		Dec 30 2020, 5:31 AM	★	★
Diff 3	24754	rHG6b40aac4da8e3b2a5b59367c71806fe4d37e282a	Dec 16 2020, 3:46 AM	★	★

Commit	Parents	Author	Summary	Date
fb9bac13a675	33791ff3bf2c	Pulkit Goyal		Dec 16 2020, 3:46 AM

Status	Author	Revision
Closed	pulkit	D9775 upgrade: update only requirements if we can
Closed	pulkit	D9774 engine: add `if True` to prepare for next patch
Closed	pulkit	D9773 test: unquiet few tests to demonstrate changes in upcoming patches
Closed	pulkit	D9772 upgrade: mark sharesafe improvement as only touching requirements
Closed	pulkit	D9771 actions: calculate what all parts does the operation touches
Closed	pulkit	D9770 upgrade: don't create store backup if `--no-backup` is passed
Changes Planned	pulkit	D9677 upgrade: use copy+delete instead of rename while creating backup
Closed	pulkit	D9695 upgrade: don't perform anything if nothing to do
Closed	pulkit	D9676 upgrade: migrated -> upgraded in ui messages
Closed	pulkit	D9675 upgrade: remove unnecessary `is None` check
Closed	pulkit	D9674 engine: refactor code to replace stores in separate function
Closed	pulkit	D9694 upgrade: demonstrate that a no-op upgrade still performs everything
Closed	pulkit	D9693 downgrade: if a compression is removed, consider that too
Closed	pulkit	D9673 engine: prevent a function call for each store file
Closed	pulkit	D9672 engine: make hook point for extension a public function
Closed	pulkit	D9669 engine: prevent multiple checking of re-delta-multibase
Closed	pulkit	D9668 engine: pass upgrade operation inside `_perform_clone()`
Closed	pulkit	D9667 engine: pass upgrade operation inside _clonerevlogs()
Closed	pulkit	D9666 actions: store deltareuse mode of whole operation in UpgradeOperation
Closed	pulkit	D9665 engine: refactor how total dstsize is calculated
Closed	pulkit	D9619 upgrade: introduce post upgrade and downgrade message for improvements
Closed	pulkit	D9618 actions: introduce function to calculate downgrades
Closed	pulkit	D9617 debugupgraderepo: minor documentation fix
Closed	pulkit	D9616 upgrade: rename actions to upgrade_actions
Closed	pulkit	D9615 upgrade: move optimization addition to determineactions()
Closed	pulkit	D9614 upgrade: drop support for old style optimization names
Closed	pulkit	D9583 upgrade: add a missing space in status message
Closed	pulkit	D9664 actions: rename DEFICIENCY constant to FORMAT_VARIANT
Closed	pulkit	D9582 upgrade: rename finddeficiences() to find_format_upgrades()
Closed	pulkit	D9580 engine: unwrap a hard to understand for loop
Closed	pulkit	D9579 engine: refactor actual cloning code into separate function
Closed	pulkit	D9578 upgrade: move printing of unused optimizations to UpgradeOperation class
Closed	pulkit	D9577 upgrade: move `printrequirements()` to UpgradeOperation class
Closed	pulkit	D9576 upgrade: move `printoptimisations() to UpgradeOperation class
Closed	pulkit	D9575 upgrade: move `printupgradeactions()` to UpgradeOperation class
Closed	pulkit	D9574 upgrade: move `print_affected_revlogs()` to UpgradeOperation class

Diff 24545

mercurial/upgrade.py

	if optimize: # anything left is unknown			if optimize: # anything left is unknown
	raise error.Abort(			raise error.Abort(
	_(b'unknown optimization action requested: %s')			_(b'unknown optimization action requested: %s')
	% b', '.join(sorted(optimize)),			% b', '.join(sorted(optimize)),
	hint=_(b'run without arguments to see valid optimizations'),			hint=_(b'run without arguments to see valid optimizations'),
	)			)

	format_upgrades = upgrade_actions.find_format_upgrades(repo)			format_upgrades = upgrade_actions.find_format_upgrades(repo)
	actions = upgrade_actions.determineactions(			up_actions = upgrade_actions.determine_upgrade_actions(
	repo, format_upgrades, optimizations, repo.requirements, newreqs			repo, format_upgrades, optimizations, repo.requirements, newreqs
	)			)

	removedreqs = repo.requirements - newreqs			removedreqs = repo.requirements - newreqs
	addedreqs = newreqs - repo.requirements			addedreqs = newreqs - repo.requirements

	if revlogs != upgrade_engine.UPGRADE_ALL_REVLOGS:			if revlogs != upgrade_engine.UPGRADE_ALL_REVLOGS:
	incompatible = upgrade_actions.RECLONES_REQUIREMENTS & (			incompatible = upgrade_actions.RECLONES_REQUIREMENTS & (
	removedreqs \| addedreqs			removedreqs \| addedreqs
	)			)
	if incompatible:			if incompatible:
	msg = _(			msg = _(
	b'ignoring revlogs selection flags, format requirements '			b'ignoring revlogs selection flags, format requirements '
	b'change: %s\n'			b'change: %s\n'
	)			)
	ui.warn(msg % b', '.join(sorted(incompatible)))			ui.warn(msg % b', '.join(sorted(incompatible)))
	revlogs = upgrade_engine.UPGRADE_ALL_REVLOGS			revlogs = upgrade_engine.UPGRADE_ALL_REVLOGS

	upgrade_op = upgrade_actions.UpgradeOperation(			upgrade_op = upgrade_actions.UpgradeOperation(
	ui,			ui,
	newreqs,			newreqs,
	repo.requirements,			repo.requirements,
	actions,			up_actions,
	revlogs,			revlogs,
	)			)

	if not run:			if not run:
	fromconfig = []			fromconfig = []
	onlydefault = []			onlydefault = []

	for d in format_upgrades:			for d in format_upgrades:

mercurial/upgrade_utils/actions.py


	def findoptimizations(repo):			def findoptimizations(repo):
	"""Determine optimisation that could be used during upgrade"""			"""Determine optimisation that could be used during upgrade"""
	# These are unconditionally added. There is logic later that figures out			# These are unconditionally added. There is logic later that figures out
	# which ones to apply.			# which ones to apply.
	return list(ALL_OPTIMISATIONS)			return list(ALL_OPTIMISATIONS)


	def determineactions(			def determine_upgrade_actions(
	repo, format_upgrades, optimizations, sourcereqs, destreqs			repo, format_upgrades, optimizations, sourcereqs, destreqs
	):			):
	"""Determine upgrade actions that will be performed.			"""Determine upgrade actions that will be performed.

	Given a list of improvements as returned by ``find_format_upgrades`` and			Given a list of improvements as returned by ``find_format_upgrades`` and
	``findoptimizations``, determine the list of upgrade actions that			``findoptimizations``, determine the list of upgrade actions that
	will be performed.			will be performed.

	class UpgradeOperation(object):			class UpgradeOperation(object):
	"""represent the work to be done during an upgrade"""			"""represent the work to be done during an upgrade"""

	def __init__(			def __init__(
	self,			self,
	ui,			ui,
	new_requirements,			new_requirements,
	current_requirements,			current_requirements,
	actions,			upgrade_actions,
	revlogs_to_process,			revlogs_to_process,
	):			):
	self.ui = ui			self.ui = ui
	self.new_requirements = new_requirements			self.new_requirements = new_requirements
	self.current_requirements = current_requirements			self.current_requirements = current_requirements
	self.actions = actions			# list of upgrae actions the operation will perform
	self._actions_names = set([a.name for a in actions])			self.upgrade_actions = upgrade_actions
				self._upgrade_actions_names = set([a.name for a in upgrade_actions])
	self.revlogs_to_process = revlogs_to_process			self.revlogs_to_process = revlogs_to_process
	# requirements which will be added by the operation			# requirements which will be added by the operation
	self._added_requirements = (			self._added_requirements = (
	self.new_requirements - self.current_requirements			self.new_requirements - self.current_requirements
	)			)
	# requirements which will be removed by the operation			# requirements which will be removed by the operation
	self._removed_requirements = (			self._removed_requirements = (
	self.current_requirements - self.new_requirements			self.current_requirements - self.new_requirements
	)			)
	# requirements which will be preserved by the operation			# requirements which will be preserved by the operation
	self._preserved_requirements = (			self._preserved_requirements = (
	self.current_requirements & self.new_requirements			self.current_requirements & self.new_requirements
	)			)
	# optimizations which are not used and it's recommended that they			# optimizations which are not used and it's recommended that they
	# should use them			# should use them
	all_optimizations = findoptimizations(None)			all_optimizations = findoptimizations(None)
	self.unused_optimizations = [			self.unused_optimizations = [
	i for i in all_optimizations if i not in self.actions			i for i in all_optimizations if i not in self.upgrade_actions
	]			]

	def _write_labeled(self, l, label):			def _write_labeled(self, l, label):
	"""			"""
	Utility function to aid writing of a list under one label			Utility function to aid writing of a list under one label
	"""			"""
	first = True			first = True
	for r in sorted(l):			for r in sorted(l):
	self.ui.write(_(b' added: '))			self.ui.write(_(b' added: '))
	self._write_labeled(			self._write_labeled(
	self._added_requirements, "upgrade-repo.requirement.added"			self._added_requirements, "upgrade-repo.requirement.added"
	)			)
	self.ui.write((b'\n'))			self.ui.write((b'\n'))
	self.ui.write(b'\n')			self.ui.write(b'\n')

	def print_optimisations(self):			def print_optimisations(self):
	optimisations = [a for a in self.actions if a.type == OPTIMISATION]			optimisations = [
				a for a in self.upgrade_actions if a.type == OPTIMISATION
				]
	optimisations.sort(key=lambda a: a.name)			optimisations.sort(key=lambda a: a.name)
	if optimisations:			if optimisations:
	self.ui.write(_(b'optimisations: '))			self.ui.write(_(b'optimisations: '))
	self._write_labeled(			self._write_labeled(
	[a.name for a in optimisations],			[a.name for a in optimisations],
	"upgrade-repo.optimisation.performed",			"upgrade-repo.optimisation.performed",
	)			)
	self.ui.write(b'\n\n')			self.ui.write(b'\n\n')

	def print_upgrade_actions(self):			def print_upgrade_actions(self):
	for a in self.actions:			for a in self.upgrade_actions:
	self.ui.status(b'%s\n %s\n\n' % (a.name, a.upgrademessage))			self.ui.status(b'%s\n %s\n\n' % (a.name, a.upgrademessage))

	def print_affected_revlogs(self):			def print_affected_revlogs(self):
	if not self.revlogs_to_process:			if not self.revlogs_to_process:
	self.ui.write((b'no revlogs to process\n'))			self.ui.write((b'no revlogs to process\n'))
	else:			else:
	self.ui.write((b'processed revlogs:\n'))			self.ui.write((b'processed revlogs:\n'))
	for r in sorted(self.revlogs_to_process):			for r in sorted(self.revlogs_to_process):
	self.ui.write((b' - %s\n' % r))			self.ui.write((b' - %s\n' % r))
	self.ui.write((b'\n'))			self.ui.write((b'\n'))

	def print_unused_optimizations(self):			def print_unused_optimizations(self):
	for i in self.unused_optimizations:			for i in self.unused_optimizations:
	self.ui.status(_(b'%s\n %s\n\n') % (i.name, i.description))			self.ui.status(_(b'%s\n %s\n\n') % (i.name, i.description))

	def has_action(self, name):			def has_upgrade_action(self, name):
	""" Check whether the upgrade operation will perform this action """			""" Check whether the upgrade operation will perform this action """
	return name in self._actions_names			return name in self._upgrade_actions_names


	### Code checking if a repository can got through the upgrade process at all. #			### Code checking if a repository can got through the upgrade process at all. #


	def requiredsourcerequirements(repo):			def requiredsourcerequirements(repo):
	"""Obtain requirements required to be present to upgrade a repo.			"""Obtain requirements required to be present to upgrade a repo.

mercurial/upgrade_utils/engine.py


	ui.status(			ui.status(
	_(			_(
	b'(it is safe to interrupt this process any time before '			b'(it is safe to interrupt this process any time before '
	b'data migration completes)\n'			b'data migration completes)\n'
	)			)
	)			)

	if upgrade_op.has_action(b're-delta-all'):			if upgrade_op.has_upgrade_action(b're-delta-all'):
	deltareuse = revlog.revlog.DELTAREUSENEVER			deltareuse = revlog.revlog.DELTAREUSENEVER
	elif upgrade_op.has_action(b're-delta-parent'):			elif upgrade_op.has_upgrade_action(b're-delta-parent'):
	deltareuse = revlog.revlog.DELTAREUSESAMEREVS			deltareuse = revlog.revlog.DELTAREUSESAMEREVS
	elif upgrade_op.has_action(b're-delta-multibase'):			elif upgrade_op.has_upgrade_action(b're-delta-multibase'):
	deltareuse = revlog.revlog.DELTAREUSESAMEREVS			deltareuse = revlog.revlog.DELTAREUSESAMEREVS
	elif upgrade_op.has_action(b're-delta-fulladd'):			elif upgrade_op.has_upgrade_action(b're-delta-fulladd'):
	deltareuse = revlog.revlog.DELTAREUSEFULLADD			deltareuse = revlog.revlog.DELTAREUSEFULLADD
	else:			else:
	deltareuse = revlog.revlog.DELTAREUSEALWAYS			deltareuse = revlog.revlog.DELTAREUSEALWAYS

	with dstrepo.transaction(b'upgrade') as tr:			with dstrepo.transaction(b'upgrade') as tr:
	_clonerevlogs(			_clonerevlogs(
	ui,			ui,
	srcrepo,			srcrepo,
	dstrepo,			dstrepo,
	tr,			tr,
	deltareuse,			deltareuse,
	upgrade_op.has_action(b're-delta-multibase'),			upgrade_op.has_upgrade_action(b're-delta-multibase'),
	revlogs=upgrade_op.revlogs_to_process,			revlogs=upgrade_op.revlogs_to_process,
	)			)

	# Now copy other files in the store directory.			# Now copy other files in the store directory.
	# The sorted() makes execution deterministic.			# The sorted() makes execution deterministic.
	for p, kind, st in sorted(srcrepo.store.vfs.readdir(b'', stat=True)):			for p, kind, st in sorted(srcrepo.store.vfs.readdir(b'', stat=True)):
	if not _filterstorefile(			if not _filterstorefile(
	srcrepo, dstrepo, upgrade_op.new_requirements, p, kind, st			srcrepo, dstrepo, upgrade_op.new_requirements, p, kind, st