def _upgrade(
self,
new_src_ver: SourceVersion,
pkg_name: str,
migrate=True,
rollback=True
):
curr_pkg_ver, _ = NodeControlUtil.curr_pkg_info(pkg_name)
if not curr_pkg_ver:
logger.error("package {} is not found".format(pkg_name))
return
logger.info(
"Current version of package '{}' is '{}'"
.format(pkg_name, curr_pkg_ver)
)
new_pkg_ver = NodeControlUtil.get_latest_pkg_version(
pkg_name, upstream=new_src_ver)
if not new_pkg_ver:
logger.error(
"Upgrade from {} to upstream version {} failed: package {} for"
" upstream version is not found"
.format(curr_pkg_ver, new_src_ver, pkg_name)
)
return
self._do_upgrade(pkg_name, curr_pkg_ver, new_pkg_ver, rollback)
def get_src_version(pkg_name: str = APP_NAME,
nocache: bool = False) -> SourceVersion:
if pkg_name == APP_NAME and not nocache:
from indy_node.__metadata__ import __version__
return src_version_cls(APP_NAME)(__version__)
curr_pkg_ver, _ = NodeControlUtil.curr_pkg_info(pkg_name)
return curr_pkg_ver.upstream if curr_pkg_ver else None
def test_curr_pkg_info(monkeypatch):
output = 'Version: 1.2.3\nDepends: aaa (= 1.2.4), bbb (>= 1.2.5), ccc, aaa'
expected_deps = ['aaa=1.2.4', 'bbb=1.2.5', 'ccc']
monkeypatch.setattr(NodeControlUtil, 'run_shell_command',
lambda *_: output)
for pkg_name in [APP_NAME, 'any_package']:
upstream_cls = src_version_cls(pkg_name)
expected_version = DebianVersion('1.2.3', upstream_cls=upstream_cls)
pkg_info = NodeControlUtil.curr_pkg_info(pkg_name)
assert expected_version == pkg_info[0]
assert isinstance(expected_version, type(pkg_info[0]))
assert isinstance(expected_version.upstream,
type(pkg_info[0].upstream))
assert expected_deps == pkg_info[1]
def didLastExecutedUpgradeSucceeded(self) -> bool:
"""
Checks last record in upgrade log to find out whether it
is about scheduling upgrade. If so - checks whether current version
is equals to the one in that record
:returns: upgrade execution result
"""
lastEventInfo = self.lastActionEventInfo
if lastEventInfo:
ev_data = lastEventInfo.data
currentPkgVersion = NodeControlUtil.curr_pkg_info(
ev_data.pkg_name)[0]
if currentPkgVersion:
return currentPkgVersion.upstream == ev_data.version
else:
logger.warning("{} failed to get information about package {} "
"scheduled for last upgrade".format(
self, ev_data.pkg_name))
return False
def check_upgrade_possible(pkg_name: str,
target_ver: str,
reinstall: bool = False):
version_cls = src_version_cls(pkg_name)
try:
target_ver = version_cls(target_ver)
except InvalidVersionError:
return ("invalid target version {} for version class {}: ".format(
target_ver, version_cls))
# get current installed package version of pkg_name
curr_pkg_ver, cur_deps = NodeControlUtil.curr_pkg_info(pkg_name)
if not curr_pkg_ver:
return ("package {} is not installed and cannot be upgraded".
format(pkg_name))
# TODO weak check
if APP_NAME not in pkg_name and all(
[APP_NAME not in d for d in cur_deps]):
return "Package {} doesn't belong to pool".format(pkg_name)
# compare whether it makes sense to try (target >= current, = for reinstall)
if not Upgrader.is_version_upgradable(curr_pkg_ver.upstream,
target_ver, reinstall):
return "Version {} is not upgradable".format(target_ver)
# get the most recent version of the package for provided version
# TODO request to NodeControlTool since Node likely runs under user
# which doesn't have rights to update list of system packages available
# target_pkg_ver = NodeControlUtil.get_latest_pkg_version(
# pkg_name, upstream=target_ver)
# if not target_pkg_ver:
# return ("package {} for target version {} is not found"
# .format(pkg_name, target_ver))
return None
def test_curr_pkg_info_no_data(monkeypatch):
monkeypatch.setattr(NodeControlUtil, 'run_shell_command', lambda *_: '')
assert (None, []) == NodeControlUtil.curr_pkg_info('any_package')