def testScheduleNodeUpgrade(tconf, nodeSet):
"""
Tests that upgrade scheduling works. For that it starts mock
control service, schedules upgrade for near future and then checks that
service received notification.
"""
loop = asyncio.get_event_loop()
server, indicator = loop.run_until_complete(
_createServer(host=tconf.controlServiceHost,
port=tconf.controlServicePort))
indicator.add_done_callback(_stopServer(server))
node = nodeSet[0]
# ATTENTION! nodeId and ledger must not be None, but there
# we do not call methods that use them, so we can pass None
# We do it because node from nodeSet is some testable object, not real
# node, so it has no nodeId and ledger that we can use
upgrader = Upgrader(nodeId=None,
nodeName=None,
dataDir=node.dataLocation,
config=tconf,
ledger=None)
upgrader._callUpgradeAgent(time.time(), "1.2", 1000, None,
tconf.UPGRADE_ENTRY)
result = loop.run_until_complete(eventuallySoon(_checkFuture(indicator)))
expectedResult = UpgradeMessage(version, tconf.UPGRADE_ENTRY)
assert result == expectedResult.toJson()
def testScheduleNodeUpgrade(tconf, nodeSet):
"""
Tests that upgrade scheduling works. For that it starts mock
control service, schedules upgrade for near future and then checks that
service received notification.
"""
loop = asyncio.get_event_loop()
server, indicator = loop.run_until_complete(
_createServer(
host=tconf.controlServiceHost,
port=tconf.controlServicePort
)
)
indicator.add_done_callback(_stopServer(server))
node = nodeSet[0]
# ATTENTION! nodeId and ledger must not be None, but there
# we do not call methods that use them, so we can pass None
# We do it because node from nodeSet is some testable object, not real
# node, so it has no nodeId and ledger that we can use
upgrader = Upgrader(nodeId=None,
nodeName=None,
dataDir=node.dataLocation,
config=tconf,
ledger=None)
upgrader._callUpgradeAgent(
time.time(), "1.2", failTimeout=1000, upgrade_id=None)
result = loop.run_until_complete(eventuallySoon(_checkFuture(indicator)))
expectedResult = UpgradeMessage(version)
assert result == expectedResult.toJson()
def _do_upgrade(
self,
pkg_name: str,
curr_pkg_ver: PackageVersion,
new_pkg_ver: PackageVersion,
rollback: bool
):
from indy_node.server.upgrader import Upgrader
cur_node_src_ver = Upgrader.get_src_version()
logger.info(
"Trying to upgrade from {}={} to {}"
.format(pkg_name, curr_pkg_ver, new_pkg_ver)
)
try:
self._call_upgrade_script(pkg_name, new_pkg_ver)
if migrate:
# TODO test for migration, should fail if nocache is False !!!
new_node_src_ver = Upgrader.get_src_version(nocache=True)
# assumption: migrations are anchored to release versions only
self._migrate(cur_node_src_ver.release, new_node_src_ver.release)
self._call_restart_node_script()
except Exception as ex:
logger.error(
"Upgrade from {} to {} failed: {}"
.format(curr_pkg_ver, new_pkg_ver, ex)
)
if rollback:
logger.error("Trying to rollback to the previous version {}"
.format(ex, curr_pkg_ver))
self._do_upgrade(
pkg_name, new_pkg_ver, curr_pkg_ver, rollback=False)
def validate(self, req: Request):
status = None
operation = req.operation
typ = operation.get(TXN_TYPE)
if typ not in [POOL_UPGRADE, POOL_CONFIG]:
return
origin = req.identifier
try:
originRole = self.idrCache.getRole(origin, isCommitted=False)
except BaseException:
raise UnauthorizedClientRequest(
req.identifier,
req.reqId,
"Nym {} not added to the ledger yet".format(origin))
if typ == POOL_UPGRADE:
currentVersion = Upgrader.getVersion()
targetVersion = req.operation[VERSION]
if Upgrader.compareVersions(currentVersion, targetVersion) < 0:
# currentVersion > targetVersion
raise InvalidClientRequest(
req.identifier,
req.reqId,
"Upgrade to lower version is not allowed")
trname = IndyTransactions.POOL_UPGRADE.name
action = operation.get(ACTION)
# TODO: Some validation needed for making sure name and version
# present
txn = self.upgrader.get_upgrade_txn(
lambda txn: txn.get(
NAME,
None) == req.operation.get(
NAME,
None) and txn.get(VERSION) == req.operation.get(VERSION),
reverse=True)
if txn:
status = txn.get(ACTION, None)
if status == START and action == START:
raise InvalidClientRequest(
req.identifier,
req.reqId,
"Upgrade '{}' is already scheduled".format(
req.operation.get(NAME)))
elif typ == POOL_CONFIG:
trname = IndyTransactions.POOL_CONFIG.name
action = None
status = None
r, msg = Authoriser.authorised(
typ, originRole, field=ACTION, oldVal=status, newVal=action)
if not r:
raise UnauthorizedClientRequest(
req.identifier, req.reqId, "{} cannot do {}".format(
Roles.nameFromValue(originRole), trname))
def validate(self, req: Request):
status = None
operation = req.operation
typ = operation.get(TXN_TYPE)
if typ not in [POOL_UPGRADE, POOL_CONFIG]:
return
origin = req.identifier
try:
originRole = self.idrCache.getRole(origin, isCommitted=False)
except BaseException:
raise UnauthorizedClientRequest(
req.identifier,
req.reqId,
"Nym {} not added to the ledger yet".format(origin))
if typ == POOL_UPGRADE:
currentVersion = Upgrader.getVersion()
targetVersion = req.operation[VERSION]
if Upgrader.compareVersions(currentVersion, targetVersion) < 0:
# currentVersion > targetVersion
raise InvalidClientRequest(
req.identifier,
req.reqId,
"Upgrade to lower version is not allowed")
trname = IndyTransactions.POOL_UPGRADE.name
action = operation.get(ACTION)
# TODO: Some validation needed for making sure name and version
# present
txn = self.upgrader.get_upgrade_txn(
lambda txn: txn.get(
NAME,
None) == req.operation.get(
NAME,
None) and txn.get(VERSION) == req.operation.get(VERSION),
reverse=True)
if txn:
status = txn.get(ACTION, None)
if status == START and action == START:
raise InvalidClientRequest(
req.identifier,
req.reqId,
"Upgrade '{}' is already scheduled".format(
req.operation.get(NAME)))
elif typ == POOL_CONFIG:
trname = IndyTransactions.POOL_CONFIG.name
action = None
status = None
r, msg = Authoriser.authorised(
typ, ACTION, originRole, oldVal=status, newVal=action)
if not r:
raise UnauthorizedClientRequest(
req.identifier, req.reqId, "{} cannot do {}".format(
Roles.nameFromValue(originRole), trname))
def _compare_migration_scripts(migration1, migration2):
migration_original_version1, migration_new_version1 = _get_migration_versions(
migration1)
migration_original_version2, migration_new_version2 = _get_migration_versions(
migration2)
if Upgrader.compareVersions(migration_original_version2,
migration_original_version1) == 0:
return Upgrader.compareVersions(migration_new_version2,
migration_new_version1)
return Upgrader.compareVersions(migration_original_version2,
migration_original_version1)
def _compare_migration_scripts(migration1, migration2):
migration_original_version1, migration_new_version1 = _get_migration_versions(
migration1)
migration_original_version2, migration_new_version2 = _get_migration_versions(
migration2)
if Upgrader.compareVersions(
migration_original_version2, migration_original_version1) == 0:
return Upgrader.compareVersions(
migration_new_version2, migration_new_version1)
return Upgrader.compareVersions(
migration_original_version2, migration_original_version1)
def test_get_src_version_for_app(monkeypatch):
called = 0
def _f(*args, **kwargs):
nonlocal called
called += 1
return (None, [])
monkeypatch.setattr(NodeControlUtil, 'curr_pkg_info', _f)
assert Upgrader.get_src_version(APP_NAME)
assert not called
Upgrader.get_src_version(APP_NAME, nocache=True)
assert called
def testNodeControlCreatesBackups(monkeypatch, tdir, looper, tconf):
version = bumpedVersion()
stdout = 'teststdout'
curr_src_ver = Upgrader.get_src_version()
def transform(tool):
nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout)
monkeypatch.setattr(tool, '_remove_old_backups', lambda *x: None)
def checkBackup(tool):
assert os.path.isfile('{}.{}'.format(
tool._backup_name(curr_src_ver.release), tool.backup_format))
monkeypatch.setattr(
NodeControlUtil, 'get_latest_pkg_version',
lambda *x, **y: DebianVersion(
version, upstream_cls=src_version_cls())
)
nct = NCT(backup_dir=tdir, backup_target=tdir, transform=transform, config=tconf)
try:
sendUpgradeMessage(version)
looper.run(eventually(checkBackup, nct.tool))
finally:
clean_dir(nct.tool.base_dir)
nct.stop()
def getUpgrader(self):
return Upgrader(self.id,
self.name,
self.dataLocation,
self.config,
self.configLedger,
upgradeFailedCallback=self.postConfigLedgerCaughtUp,
upgrade_start_callback=self.notify_upgrade_start)
def init_upgrader(self):
return Upgrader(self.node.id,
self.node.name,
self.node.dataLocation,
self.node.config,
self.node.configLedger,
actionFailedCallback=self.node.postConfigLedgerCaughtUp,
action_start_callback=self.node.notify_upgrade_start)
def _get_relevant_migrations(migration_scripts, current_version, new_version):
relevant_migrations = []
for migration in migration_scripts:
migration_original_version, migration_new_version = _get_migration_versions(
migration)
if not migration_original_version or not migration_new_version:
continue
if Upgrader.compareVersions(current_version, new_version) >= 0:
if Upgrader.compareVersions(
migration_new_version, migration_original_version) > 0:
continue
if Upgrader.compareVersions(migration_original_version, current_version) <= 0 \
and Upgrader.compareVersions(migration_new_version, new_version) >= 0:
relevant_migrations.append(migration)
else:
if Upgrader.compareVersions(
migration_original_version, migration_new_version) > 0:
continue
if Upgrader.compareVersions(migration_original_version, current_version) >= 0 \
and Upgrader.compareVersions(migration_new_version, new_version) <= 0:
relevant_migrations.append(migration)
relevant_migrations = sorted(
relevant_migrations, key=cmp_to_key(_compare_migration_scripts))
return relevant_migrations
def _get_relevant_migrations(migration_scripts, current_version, new_version):
relevant_migrations = []
for migration in migration_scripts:
migration_original_version, migration_new_version = _get_migration_versions(
migration)
if not migration_original_version or not migration_new_version:
continue
if Upgrader.compareVersions(current_version, new_version) >= 0:
if Upgrader.compareVersions(migration_new_version,
migration_original_version) > 0:
continue
if Upgrader.compareVersions(migration_original_version, current_version) <= 0 \
and Upgrader.compareVersions(migration_new_version, new_version) >= 0:
relevant_migrations.append(migration)
else:
if Upgrader.compareVersions(migration_original_version,
migration_new_version) > 0:
continue
if Upgrader.compareVersions(migration_original_version, current_version) >= 0 \
and Upgrader.compareVersions(migration_new_version, new_version) <= 0:
relevant_migrations.append(migration)
relevant_migrations = sorted(
relevant_migrations, key=cmp_to_key(_compare_migration_scripts))
return relevant_migrations
def _upgrade(self, new_version, pkg_name, migrate=True, rollback=True):
current_version, _ = NodeControlUtil.curr_pkt_info(pkg_name)
try:
from indy_node.server.upgrader import Upgrader
node_cur_version = Upgrader.getVersion()
logger.info('Trying to upgrade from {}={} to {}'.format(pkg_name, current_version, new_version))
self._call_upgrade_script(pkg_name, new_version)
if migrate:
node_new_version = Upgrader.getVersion()
self._do_migration(node_cur_version, node_new_version)
self._call_restart_node_script()
except Exception as ex:
self._declare_upgrade_failed(from_version=current_version,
to_version=new_version,
reason=str(ex))
logger.error("Trying to rollback to the previous version {}"
.format(ex, current_version))
if rollback:
self._upgrade(current_version, pkg_name, rollback=False)
def comparator_test(lower_versrion, higher_version):
assert Upgrader.compareVersions(lower_versrion, higher_version) == 1
assert Upgrader.compareVersions(higher_version, lower_versrion) == -1
assert Upgrader.compareVersions(higher_version, higher_version) == 0
assert not Upgrader.is_version_upgradable(higher_version, higher_version)
assert Upgrader.is_version_upgradable(
higher_version, higher_version, reinstall=True)
assert Upgrader.is_version_upgradable(lower_versrion, higher_version)
assert Upgrader.is_version_upgradable(higher_version, lower_versrion)
def comparator_test(lower_versrion, higher_version):
assert Upgrader.compareVersions(lower_versrion, higher_version) == 1
assert Upgrader.compareVersions(higher_version, lower_versrion) == -1
assert Upgrader.compareVersions(higher_version, higher_version) == 0
assert not Upgrader.is_version_upgradable(higher_version, higher_version)
assert Upgrader.is_version_upgradable(
higher_version, higher_version, reinstall=True)
assert Upgrader.is_version_upgradable(lower_versrion, higher_version)
assert not Upgrader.is_version_upgradable(higher_version, lower_versrion)
def _upgrade(self, new_version, migrate=True, rollback=True):
current_version = self.ext_ver if self.ext_ver else Upgrader.getVersion(
)
try:
logger.info('Trying to upgrade from {} to {}'.format(
current_version, new_version))
self._call_upgrade_script(new_version)
if migrate:
# migration should only be called with current version from Upgrader!
self._do_migration(Upgrader.getVersion(), new_version)
self._call_restart_node_script()
except Exception as ex:
self._declare_upgrade_failed(from_version=current_version,
to_version=new_version,
reason=str(ex))
logger.error(
"Trying to rollback to the previous version {}".format(
ex, current_version))
if rollback:
self._upgrade(current_version, rollback=False)
def dynamic_validation(self, request: Request):
self._validate_request_type(request)
identifier, req_id, operation = get_request_data(request)
status = '*'
pkt_to_upgrade = operation.get(PACKAGE, getConfig().UPGRADE_ENTRY)
if pkt_to_upgrade:
currentVersion, cur_deps = self.curr_pkt_info(pkt_to_upgrade)
if not currentVersion:
raise InvalidClientRequest(
identifier, req_id,
"Packet {} is not installed and cannot be upgraded".format(
pkt_to_upgrade))
if all([APP_NAME not in d for d in cur_deps]):
raise InvalidClientRequest(
identifier, req_id,
"Packet {} doesn't belong to pool".format(pkt_to_upgrade))
else:
raise InvalidClientRequest(identifier, req_id,
"Upgrade packet name is empty")
targetVersion = operation[VERSION]
reinstall = operation.get(REINSTALL, False)
if not Upgrader.is_version_upgradable(currentVersion, targetVersion,
reinstall):
# currentVersion > targetVersion
raise InvalidClientRequest(identifier, req_id,
"Version is not upgradable")
action = operation.get(ACTION)
# TODO: Some validation needed for making sure name and version
# present
txn = self.upgrader.get_upgrade_txn(
lambda txn: get_payload_data(txn).get(NAME, None) == operation.get(
NAME, None) and get_payload_data(txn).get(
VERSION) == operation.get(VERSION),
reverse=True)
if txn:
status = get_payload_data(txn).get(ACTION, '*')
if status == START and action == START:
raise InvalidClientRequest(
identifier, req_id, "Upgrade '{}' is already scheduled".format(
operation.get(NAME)))
if status == '*':
auth_action = AuthActionAdd(txn_type=POOL_UPGRADE,
field=ACTION,
value=action)
else:
auth_action = AuthActionEdit(txn_type=POOL_UPGRADE,
field=ACTION,
old_value=status,
new_value=action)
self.write_request_validator.validate(request, [auth_action])
def _upgrade(self, new_version, migrate=True, rollback=True):
try:
current_version = Upgrader.getVersion()
logger.info('Trying to upgrade from {} to {}'.format(
current_version, new_version))
self._call_upgrade_script(new_version)
if migrate:
self._do_migration(current_version, new_version)
self._call_restart_node_script()
except Exception as e:
logger.error(
"Unexpected error in _upgrade {}, trying to rollback to the previous version {}"
.format(e, current_version))
if rollback:
self._upgrade(current_version, rollback=False)
def test_versions_comparison(lower_version, higher_version):
assert Upgrader.compareVersions(higher_version, lower_version) == 1
assert Upgrader.compareVersions(lower_version, higher_version) == -1
assert Upgrader.compareVersions(higher_version, higher_version) == 0
version_cls = src_version_cls(APP_NAME)
lower_version = version_cls(lower_version)
higher_version = version_cls(higher_version)
assert not Upgrader.is_version_upgradable(higher_version, higher_version)
assert Upgrader.is_version_upgradable(higher_version,
higher_version,
reinstall=True)
assert Upgrader.is_version_upgradable(lower_version, higher_version)
assert not Upgrader.is_version_upgradable(higher_version, lower_version)
def testNodeControlRemovesBackups(monkeypatch, tdir, looper, tconf):
version = bumpedVersion()
stdout = 'teststdout'
curr_src_ver = Upgrader.get_src_version()
backupsWereRemoved = m.Value('b', False)
def testRemoveOldBackups(tool):
assert len(tool._get_backups()) == (tool.backup_num + 1)
#looper = Looper(debug=True)
tool._remove_old_backups_test()
backupsWereRemoved.value = True
def transform(tool):
nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout)
tool._remove_old_backups_test = tool._remove_old_backups
monkeypatch.setattr(tool, '_remove_old_backups',
functools.partial(testRemoveOldBackups, tool))
def checkOldBackupsRemoved():
assert backupsWereRemoved.value
def check_backups_files_exists():
assert os.path.exists('{}.{}'.format(
nct.tool._backup_name(curr_src_ver.release),
nct.tool.backup_format))
monkeypatch.setattr(
NodeControlUtil, 'get_latest_pkg_version',
lambda *x, **y: DebianVersion(version, upstream_cls=src_version_cls()))
nct = NCT(backup_dir=tdir, backup_target=tdir, transform=transform)
try:
assert len(nct.tool._get_backups()) == 0
for i in range(nct.tool.backup_num):
file = os.path.join(nct.tool.base_dir,
'{}{}'.format(nct.tool.backup_name_prefix, i))
with open(file, 'w') as f:
f.write('random')
assert len(nct.tool._get_backups()) == nct.tool.backup_num
sendUpgradeMessage(version)
looper.run(eventually(checkOldBackupsRemoved))
looper.run(eventually(check_backups_files_exists))
assert len(nct.tool._get_backups()) == nct.tool.backup_num
finally:
clean_dir(nct.tool.base_dir)
nct.stop()
def _upgrade(self, new_version, migrate=True, rollback=True):
current_version = Upgrader.getVersion()
try:
logger.info('Trying to upgrade from {} to {}'
.format(current_version, new_version))
self._call_upgrade_script(new_version)
if migrate:
self._do_migration(current_version, new_version)
self._call_restart_node_script()
except Exception as ex:
self._declare_upgrade_failed(from_version=current_version,
to_version=new_version,
reason=str(ex))
logger.error("Trying to rollback to the previous version {}"
.format(ex, current_version))
if rollback:
self._upgrade(current_version, rollback=False)
def testNodeControlCreatesBackups(monkeypatch, tdir, looper, tconf):
msg = 'test'
stdout = 'teststdout'
currentVersion = Upgrader.getVersion()
def transform(tool):
nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout)
monkeypatch.setattr(tool, '_remove_old_backups', lambda *x: None)
def checkBackup(tool):
assert os.path.isfile('{}.{}'.format(
tool._backup_name(currentVersion), tool.backup_format))
nct = NCT(backup_dir=tdir, backup_target=tdir, transform=transform)
try:
sendUpgradeMessage(msg)
looper.run(eventually(checkBackup, nct.tool))
finally:
clean_dir(nct.tool.base_dir)
nct.stop()
def testNodeControlCreatesBackups(monkeypatch, tdir, looper):
msg = 'test'
stdout = 'teststdout'
currentVersion = Upgrader.getVersion()
def transform(tool):
nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout)
monkeypatch.setattr(tool, '_remove_old_backups', lambda *x: None)
def checkBackup(tool):
assert os.path.isfile('{}.{}'.format(
tool._backup_name(currentVersion), tool.backup_format))
nct = NCT(backup_dir=tdir, backup_target=tdir, transform=transform)
try:
sendUpgradeMessage(msg)
looper.run(eventually(checkBackup, nct.tool))
finally:
clean_dir(nct.tool.base_dir)
nct.stop()
def testNodeControlRestoresFromBackups(monkeypatch, tdir, looper, tconf):
msg = 'test'
stdout = 'teststdout'
currentVersion = Upgrader.getVersion()
backupWasRestored = m.Value('b', False)
testFile = 'testFile'
original_text = '1'
new_text = '2'
def testRestoreBackup(tool, version):
tool._restore_from_backup_test(version)
backupWasRestored.value = True
def mockMigrate(tool, *args):
monkeypatch.setattr(tool, '_migrate', lambda *args: None)
with open(os.path.join(tool.indy_dir, testFile), 'w') as f:
f.write(new_text)
raise Exception('test')
def transform(tool):
nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout)
tool._restore_from_backup_test = tool._restore_from_backup
monkeypatch.setattr(
tool, '_migrate', functools.partial(mockMigrate, tool))
monkeypatch.setattr(tool, '_restore_from_backup',
functools.partial(testRestoreBackup, tool))
def checkBackupRestored(tool):
assert backupWasRestored.value
nct = NCT(backup_dir=tdir, backup_target=tdir, transform=transform)
try:
with open(os.path.join(nct.tool.indy_dir, testFile), 'w') as f:
f.write(original_text)
sendUpgradeMessage(msg)
looper.run(eventually(checkBackupRestored, nct.tool))
with open(os.path.join(nct.tool.indy_dir, testFile)) as f:
assert original_text == f.read()
finally:
clean_dir(nct.tool.base_dir)
nct.stop()
def testNodeControlRestoresFromBackups(monkeypatch, tdir, looper, tconf):
msg = 'test'
stdout = 'teststdout'
currentVersion = Upgrader.getVersion()
backupWasRestored = m.Value('b', False)
testFile = 'testFile'
original_text = '1'
new_text = '2'
def testRestoreBackup(tool, version):
tool._restore_from_backup_test(version)
backupWasRestored.value = True
def mockMigrate(tool, *args):
monkeypatch.setattr(tool, '_migrate', lambda *args: None)
with open(os.path.join(tool.indy_dir, testFile), 'w') as f:
f.write(new_text)
raise Exception('test')
def transform(tool):
nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout)
tool._restore_from_backup_test = tool._restore_from_backup
monkeypatch.setattr(tool, '_migrate',
functools.partial(mockMigrate, tool))
monkeypatch.setattr(tool, '_restore_from_backup',
functools.partial(testRestoreBackup, tool))
def checkBackupRestored(tool):
assert backupWasRestored.value
nct = NCT(backup_dir=tdir, backup_target=tdir, transform=transform)
try:
with open(os.path.join(nct.tool.indy_dir, testFile), 'w') as f:
f.write(original_text)
sendUpgradeMessage(msg)
looper.run(eventually(checkBackupRestored, nct.tool))
with open(os.path.join(nct.tool.indy_dir, testFile)) as f:
assert original_text == f.read()
finally:
clean_dir(nct.tool.base_dir)
nct.stop()
def testNodeControlRemovesBackups(monkeypatch, tdir, looper):
msg = 'test'
stdout = 'teststdout'
currentVersion = Upgrader.getVersion()
backupsWereRemoved = m.Value('b', False)
def testRemoveOldBackups(tool):
assert len(tool._get_backups()) == (tool.backup_num + 1)
#looper = Looper(debug=True)
tool._remove_old_backups_test()
backupsWereRemoved.value = True
def transform(tool):
nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout)
tool._remove_old_backups_test = tool._remove_old_backups
monkeypatch.setattr(tool, '_remove_old_backups',
functools.partial(testRemoveOldBackups, tool))
def checkOldBackupsRemoved():
assert backupsWereRemoved.value
def check_backups_files_exists():
assert os.path.exists('{}.{}'.format(
nct.tool._backup_name(currentVersion), nct.tool.backup_format))
nct = NCT(backup_dir=tdir, backup_target=tdir, transform=transform)
try:
assert len(nct.tool._get_backups()) == 0
for i in range(nct.tool.backup_num):
file = os.path.join(nct.tool.base_dir, '{}{}'.format(
nct.tool.backup_name_prefix, i))
with open(file, 'w') as f:
f.write('random')
assert len(nct.tool._get_backups()) == nct.tool.backup_num
sendUpgradeMessage(msg)
looper.run(eventually(checkOldBackupsRemoved))
looper.run(eventually(check_backups_files_exists))
assert len(nct.tool._get_backups()) == nct.tool.backup_num
finally:
clean_dir(nct.tool.base_dir)
nct.stop()
def testNodeControlRemovesBackups(monkeypatch, tdir, looper):
msg = 'test'
stdout = 'teststdout'
currentVersion = Upgrader.getVersion()
backupsWereRemoved = m.Value('b', False)
def testRemoveOldBackups(tool):
assert len(tool._get_backups()) == (tool.backup_num + 1)
tool._remove_old_backups_test()
backupsWereRemoved.value = True
def transform(tool):
nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout)
tool._remove_old_backups_test = tool._remove_old_backups
monkeypatch.setattr(tool, '_remove_old_backups',
functools.partial(testRemoveOldBackups, tool))
def checkOldBackupsRemoved():
assert backupsWereRemoved.value
nct = NCT(transform=transform)
try:
assert len(nct.tool._get_backups()) == 0
for i in range(nct.tool.backup_num):
file = os.path.join(nct.tool.base_dir,
'{}{}'.format(nct.tool.backup_name_prefix, i))
with open(file, 'w') as f:
f.write('random')
assert len(nct.tool._get_backups()) == nct.tool.backup_num
sendUpgradeMessage(msg)
looper.run(eventually(checkOldBackupsRemoved))
assert os.path.exists('{}.{}'.format(
nct.tool._backup_name(currentVersion), nct.tool.backup_format))
assert len(nct.tool._get_backups()) == nct.tool.backup_num
finally:
clean_dir(nct.tool.base_dir)
nct.stop()
def test_check_upgrade_possible_invalid_top_level_pkg():
assert ("doesn't belong to pool"
in Upgrader.check_upgrade_possible(some_pkg_name, '1.2.3'))
def test_check_upgrade_possible_reinstall_succeeded_for_app_pkg():
assert not Upgrader.check_upgrade_possible(
APP_NAME, '1.2.2', reinstall=True)
def test_check_upgrade_possible_not_ge_version_reinstall():
assert ("is not upgradable"
in Upgrader.check_upgrade_possible(some_pkg_name,
'1.2.1',
reinstall=True))
def test_check_upgrade_possible_not_gt_version():
assert ("is not upgradable"
in Upgrader.check_upgrade_possible(some_pkg_name, '1.2.2'))
def test_check_upgrade_possible_no_pkg_with_target_version():
target_ver = '1.2.3'
assert ("for target version {} is not found".format(target_ver)
in Upgrader.check_upgrade_possible(some_pkg_name, target_ver))
def curr_pkt_info(self, pkg_name):
if pkg_name == APP_NAME:
return Upgrader.getVersion(), [APP_NAME]
return NodeControlUtil.curr_pkt_info(pkg_name)
def test_check_upgrade_possible_succeeded():
target_ver = '1.2.3'
assert not Upgrader.check_upgrade_possible(some_pkg_name, target_ver)
assert not Upgrader.check_upgrade_possible(
some_pkg_name, target_ver, reinstall=True)
def test_check_upgrade_possible_succeeded_for_app_pkg():
target_ver = '1.2.3'
assert not Upgrader.check_upgrade_possible(APP_NAME, target_ver)
assert not Upgrader.check_upgrade_possible(
APP_NAME, target_ver, reinstall=True)
def test_check_upgrade_possible_reinstall_succeeded():
assert not Upgrader.check_upgrade_possible(
some_pkg_name, '1.2.2', reinstall=True)
def test_get_src_version_for(monkeypatch):
assert (Upgrader.get_src_version(some_pkg_name) == src_version_cls(
some_pkg_name)('1.2.2'))
def codeVersion():
return Upgrader.getVersion()
