b6aed193e5
In many cases we just want an effect of qmp command and want to raise
on failure. Use vm.cmd() method which does exactly this.
The commit is generated by command
git grep -l '\.qmp(' | xargs ./scripts/python_qmp_updater.py
And then, fix self.assertRaises to expect ExecuteError exception in
tests/qemu-iotests/124
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 20231006154125.1068348-16-vsementsov@yandex-team.ru
Signed-off-by: John Snow <jsnow@redhat.com>
687 lines
23 KiB
Python
Executable File
687 lines
23 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# group: migration
|
|
#
|
|
# Copyright (C) 2020 Red Hat, Inc.
|
|
#
|
|
# Tests for dirty bitmaps migration with node aliases
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
|
|
import os
|
|
import random
|
|
import re
|
|
from typing import Dict, List, Optional
|
|
|
|
import iotests
|
|
|
|
|
|
BlockBitmapMapping = List[Dict[str, object]]
|
|
|
|
mig_sock = os.path.join(iotests.sock_dir, 'mig_sock')
|
|
|
|
|
|
class TestDirtyBitmapMigration(iotests.QMPTestCase):
|
|
src_node_name: str = ''
|
|
dst_node_name: str = ''
|
|
src_bmap_name: str = ''
|
|
dst_bmap_name: str = ''
|
|
|
|
def setUp(self) -> None:
|
|
self.vm_a = iotests.VM(path_suffix='-a')
|
|
self.vm_a.add_blockdev(f'node-name={self.src_node_name},'
|
|
'driver=null-co')
|
|
self.vm_a.launch()
|
|
|
|
self.vm_b = iotests.VM(path_suffix='-b')
|
|
self.vm_b.add_blockdev(f'node-name={self.dst_node_name},'
|
|
'driver=null-co')
|
|
self.vm_b.add_incoming(f'unix:{mig_sock}')
|
|
self.vm_b.launch()
|
|
|
|
self.vm_a.cmd('block-dirty-bitmap-add',
|
|
node=self.src_node_name,
|
|
name=self.src_bmap_name)
|
|
|
|
# Dirty some random megabytes
|
|
for _ in range(9):
|
|
mb_ofs = random.randrange(1024)
|
|
self.vm_a.hmp_qemu_io(self.src_node_name, f'discard {mb_ofs}M 1M')
|
|
|
|
result = self.vm_a.qmp('x-debug-block-dirty-bitmap-sha256',
|
|
node=self.src_node_name,
|
|
name=self.src_bmap_name)
|
|
self.bitmap_hash_reference = result['return']['sha256']
|
|
|
|
caps = [{'capability': name, 'state': True}
|
|
for name in ('dirty-bitmaps', 'events')]
|
|
|
|
for vm in (self.vm_a, self.vm_b):
|
|
vm.cmd('migrate-set-capabilities', capabilities=caps)
|
|
|
|
def tearDown(self) -> None:
|
|
self.vm_a.shutdown()
|
|
self.vm_b.shutdown()
|
|
try:
|
|
os.remove(mig_sock)
|
|
except OSError:
|
|
pass
|
|
|
|
def check_bitmap(self, bitmap_name_valid: bool) -> None:
|
|
result = self.vm_b.qmp('x-debug-block-dirty-bitmap-sha256',
|
|
node=self.dst_node_name,
|
|
name=self.dst_bmap_name)
|
|
if bitmap_name_valid:
|
|
self.assert_qmp(result, 'return/sha256',
|
|
self.bitmap_hash_reference)
|
|
else:
|
|
self.assert_qmp(result, 'error/desc',
|
|
f"Dirty bitmap '{self.dst_bmap_name}' not found")
|
|
|
|
def migrate(self, bitmap_name_valid: bool = True,
|
|
migration_success: bool = True) -> None:
|
|
self.vm_a.cmd('migrate', uri=f'unix:{mig_sock}')
|
|
|
|
with iotests.Timeout(5, 'Timeout waiting for migration to complete'):
|
|
self.assertEqual(self.vm_a.wait_migration('postmigrate'),
|
|
migration_success)
|
|
self.assertEqual(self.vm_b.wait_migration('running'),
|
|
migration_success)
|
|
|
|
if migration_success:
|
|
self.check_bitmap(bitmap_name_valid)
|
|
|
|
def verify_dest_error(self, msg: Optional[str]) -> None:
|
|
"""
|
|
Check whether the given error message is present in vm_b's log.
|
|
(vm_b is shut down to do so.)
|
|
If @msg is None, check that there has not been any error.
|
|
"""
|
|
self.vm_b.shutdown()
|
|
|
|
log = self.vm_b.get_log()
|
|
assert log is not None # Loaded after shutdown
|
|
|
|
if msg is None:
|
|
self.assertNotIn('qemu-system-', log)
|
|
else:
|
|
self.assertIn(msg, log)
|
|
|
|
@staticmethod
|
|
def mapping(node_name: str, node_alias: str,
|
|
bitmap_name: str, bitmap_alias: str) -> BlockBitmapMapping:
|
|
return [{
|
|
'node-name': node_name,
|
|
'alias': node_alias,
|
|
'bitmaps': [{
|
|
'name': bitmap_name,
|
|
'alias': bitmap_alias
|
|
}]
|
|
}]
|
|
|
|
def set_mapping(self, vm: iotests.VM, mapping: BlockBitmapMapping,
|
|
error: Optional[str] = None) -> None:
|
|
"""
|
|
Invoke migrate-set-parameters on @vm to set the given @mapping.
|
|
Check for success if @error is None, or verify the error message
|
|
if it is not.
|
|
On success, verify that "info migrate_parameters" on HMP returns
|
|
our mapping. (Just to check its formatting code.)
|
|
"""
|
|
result = vm.qmp('migrate-set-parameters',
|
|
block_bitmap_mapping=mapping)
|
|
|
|
if error is None:
|
|
self.assert_qmp(result, 'return', {})
|
|
|
|
result = vm.qmp('human-monitor-command',
|
|
command_line='info migrate_parameters')
|
|
|
|
m = re.search(r'^block-bitmap-mapping:\r?(\n .*)*\n',
|
|
result['return'], flags=re.MULTILINE)
|
|
hmp_mapping = m.group(0).replace('\r', '') if m else None
|
|
|
|
self.assertEqual(hmp_mapping, self.to_hmp_mapping(mapping))
|
|
else:
|
|
self.assert_qmp(result, 'error/desc', error)
|
|
|
|
@staticmethod
|
|
def to_hmp_mapping(mapping: BlockBitmapMapping) -> str:
|
|
result = 'block-bitmap-mapping:\n'
|
|
|
|
for node in mapping:
|
|
result += f" '{node['node-name']}' -> '{node['alias']}'\n"
|
|
|
|
assert isinstance(node['bitmaps'], list)
|
|
for bitmap in node['bitmaps']:
|
|
result += f" '{bitmap['name']}' -> '{bitmap['alias']}'\n"
|
|
|
|
return result
|
|
|
|
|
|
class TestAliasMigration(TestDirtyBitmapMigration):
|
|
src_node_name = 'node0'
|
|
dst_node_name = 'node0'
|
|
src_bmap_name = 'bmap0'
|
|
dst_bmap_name = 'bmap0'
|
|
|
|
def test_migration_without_alias(self) -> None:
|
|
self.migrate(self.src_node_name == self.dst_node_name and
|
|
self.src_bmap_name == self.dst_bmap_name)
|
|
|
|
# Check for error message on the destination
|
|
if self.src_node_name != self.dst_node_name:
|
|
self.verify_dest_error(f"Cannot find "
|
|
f"device='{self.src_node_name}' nor "
|
|
f"node-name='{self.src_node_name}'")
|
|
else:
|
|
self.verify_dest_error(None)
|
|
|
|
def test_alias_on_src_migration(self) -> None:
|
|
mapping = self.mapping(self.src_node_name, self.dst_node_name,
|
|
self.src_bmap_name, self.dst_bmap_name)
|
|
|
|
self.set_mapping(self.vm_a, mapping)
|
|
self.migrate()
|
|
self.verify_dest_error(None)
|
|
|
|
def test_alias_on_dst_migration(self) -> None:
|
|
mapping = self.mapping(self.dst_node_name, self.src_node_name,
|
|
self.dst_bmap_name, self.src_bmap_name)
|
|
|
|
self.set_mapping(self.vm_b, mapping)
|
|
self.migrate()
|
|
self.verify_dest_error(None)
|
|
|
|
def test_alias_on_both_migration(self) -> None:
|
|
src_map = self.mapping(self.src_node_name, 'node-alias',
|
|
self.src_bmap_name, 'bmap-alias')
|
|
|
|
dst_map = self.mapping(self.dst_node_name, 'node-alias',
|
|
self.dst_bmap_name, 'bmap-alias')
|
|
|
|
self.set_mapping(self.vm_a, src_map)
|
|
self.set_mapping(self.vm_b, dst_map)
|
|
self.migrate()
|
|
self.verify_dest_error(None)
|
|
|
|
|
|
class TestNodeAliasMigration(TestAliasMigration):
|
|
src_node_name = 'node-src'
|
|
dst_node_name = 'node-dst'
|
|
|
|
|
|
class TestBitmapAliasMigration(TestAliasMigration):
|
|
src_bmap_name = 'bmap-src'
|
|
dst_bmap_name = 'bmap-dst'
|
|
|
|
|
|
class TestFullAliasMigration(TestAliasMigration):
|
|
src_node_name = 'node-src'
|
|
dst_node_name = 'node-dst'
|
|
src_bmap_name = 'bmap-src'
|
|
dst_bmap_name = 'bmap-dst'
|
|
|
|
|
|
class TestLongBitmapNames(TestAliasMigration):
|
|
# Giving long bitmap names is OK, as long as there is a short alias for
|
|
# migration
|
|
src_bmap_name = 'a' * 512
|
|
dst_bmap_name = 'b' * 512
|
|
|
|
# Skip all tests that do not use the intermediate alias
|
|
def test_migration_without_alias(self) -> None:
|
|
pass
|
|
|
|
def test_alias_on_src_migration(self) -> None:
|
|
pass
|
|
|
|
def test_alias_on_dst_migration(self) -> None:
|
|
pass
|
|
|
|
|
|
class TestBlockBitmapMappingErrors(TestDirtyBitmapMigration):
|
|
src_node_name = 'node0'
|
|
dst_node_name = 'node0'
|
|
src_bmap_name = 'bmap0'
|
|
dst_bmap_name = 'bmap0'
|
|
|
|
"""
|
|
Note that mapping nodes or bitmaps that do not exist is not an error.
|
|
"""
|
|
|
|
def test_non_injective_node_mapping(self) -> None:
|
|
mapping: BlockBitmapMapping = [
|
|
{
|
|
'node-name': 'node0',
|
|
'alias': 'common-alias',
|
|
'bitmaps': [{
|
|
'name': 'bmap0',
|
|
'alias': 'bmap-alias0'
|
|
}]
|
|
},
|
|
{
|
|
'node-name': 'node1',
|
|
'alias': 'common-alias',
|
|
'bitmaps': [{
|
|
'name': 'bmap1',
|
|
'alias': 'bmap-alias1'
|
|
}]
|
|
}
|
|
]
|
|
|
|
self.set_mapping(self.vm_a, mapping,
|
|
"Invalid mapping given for block-bitmap-mapping: "
|
|
"The node alias 'common-alias' is used twice")
|
|
|
|
def test_non_injective_bitmap_mapping(self) -> None:
|
|
mapping: BlockBitmapMapping = [{
|
|
'node-name': 'node0',
|
|
'alias': 'node-alias0',
|
|
'bitmaps': [
|
|
{
|
|
'name': 'bmap0',
|
|
'alias': 'common-alias'
|
|
},
|
|
{
|
|
'name': 'bmap1',
|
|
'alias': 'common-alias'
|
|
}
|
|
]
|
|
}]
|
|
|
|
self.set_mapping(self.vm_a, mapping,
|
|
"Invalid mapping given for block-bitmap-mapping: "
|
|
"The bitmap alias 'node-alias0'/'common-alias' is "
|
|
"used twice")
|
|
|
|
def test_ambiguous_node_mapping(self) -> None:
|
|
mapping: BlockBitmapMapping = [
|
|
{
|
|
'node-name': 'node0',
|
|
'alias': 'node-alias0',
|
|
'bitmaps': [{
|
|
'name': 'bmap0',
|
|
'alias': 'bmap-alias0'
|
|
}]
|
|
},
|
|
{
|
|
'node-name': 'node0',
|
|
'alias': 'node-alias1',
|
|
'bitmaps': [{
|
|
'name': 'bmap0',
|
|
'alias': 'bmap-alias0'
|
|
}]
|
|
}
|
|
]
|
|
|
|
self.set_mapping(self.vm_a, mapping,
|
|
"Invalid mapping given for block-bitmap-mapping: "
|
|
"The node name 'node0' is mapped twice")
|
|
|
|
def test_ambiguous_bitmap_mapping(self) -> None:
|
|
mapping: BlockBitmapMapping = [{
|
|
'node-name': 'node0',
|
|
'alias': 'node-alias0',
|
|
'bitmaps': [
|
|
{
|
|
'name': 'bmap0',
|
|
'alias': 'bmap-alias0'
|
|
},
|
|
{
|
|
'name': 'bmap0',
|
|
'alias': 'bmap-alias1'
|
|
}
|
|
]
|
|
}]
|
|
|
|
self.set_mapping(self.vm_a, mapping,
|
|
"Invalid mapping given for block-bitmap-mapping: "
|
|
"The bitmap 'node0'/'bmap0' is mapped twice")
|
|
|
|
def test_migratee_node_is_not_mapped_on_src(self) -> None:
|
|
self.set_mapping(self.vm_a, [])
|
|
# Should just ignore all bitmaps on unmapped nodes
|
|
self.migrate(False)
|
|
self.verify_dest_error(None)
|
|
|
|
def test_migratee_node_is_not_mapped_on_dst(self) -> None:
|
|
self.set_mapping(self.vm_b, [])
|
|
self.migrate(False)
|
|
self.verify_dest_error(f"Unknown node alias '{self.src_node_name}'")
|
|
|
|
def test_migratee_bitmap_is_not_mapped_on_src(self) -> None:
|
|
mapping: BlockBitmapMapping = [{
|
|
'node-name': self.src_node_name,
|
|
'alias': self.dst_node_name,
|
|
'bitmaps': []
|
|
}]
|
|
|
|
self.set_mapping(self.vm_a, mapping)
|
|
# Should just ignore all unmapped bitmaps
|
|
self.migrate(False)
|
|
self.verify_dest_error(None)
|
|
|
|
def test_migratee_bitmap_is_not_mapped_on_dst(self) -> None:
|
|
mapping: BlockBitmapMapping = [{
|
|
'node-name': self.dst_node_name,
|
|
'alias': self.src_node_name,
|
|
'bitmaps': []
|
|
}]
|
|
|
|
self.set_mapping(self.vm_b, mapping)
|
|
self.migrate(False)
|
|
self.verify_dest_error(f"Unknown bitmap alias "
|
|
f"'{self.src_bmap_name}' "
|
|
f"on node '{self.dst_node_name}' "
|
|
f"(alias '{self.src_node_name}')")
|
|
|
|
def test_unused_mapping_on_dst(self) -> None:
|
|
# Let the source not send any bitmaps
|
|
self.set_mapping(self.vm_a, [])
|
|
|
|
# Establish some mapping on the destination
|
|
self.set_mapping(self.vm_b, [])
|
|
|
|
# The fact that there is a mapping on B without any bitmaps
|
|
# being received should be fine, not fatal
|
|
self.migrate(False)
|
|
self.verify_dest_error(None)
|
|
|
|
def test_non_wellformed_node_alias(self) -> None:
|
|
alias = '123-foo'
|
|
|
|
mapping: BlockBitmapMapping = [{
|
|
'node-name': self.src_node_name,
|
|
'alias': alias,
|
|
'bitmaps': []
|
|
}]
|
|
|
|
self.set_mapping(self.vm_a, mapping,
|
|
f"Invalid mapping given for block-bitmap-mapping: "
|
|
f"The node alias '{alias}' is not well-formed")
|
|
|
|
def test_node_alias_too_long(self) -> None:
|
|
alias = 'a' * 256
|
|
|
|
mapping: BlockBitmapMapping = [{
|
|
'node-name': self.src_node_name,
|
|
'alias': alias,
|
|
'bitmaps': []
|
|
}]
|
|
|
|
self.set_mapping(self.vm_a, mapping,
|
|
f"Invalid mapping given for block-bitmap-mapping: "
|
|
f"The node alias '{alias}' is longer than 255 bytes")
|
|
|
|
def test_bitmap_alias_too_long(self) -> None:
|
|
alias = 'a' * 256
|
|
|
|
mapping = self.mapping(self.src_node_name, self.dst_node_name,
|
|
self.src_bmap_name, alias)
|
|
|
|
self.set_mapping(self.vm_a, mapping,
|
|
f"Invalid mapping given for block-bitmap-mapping: "
|
|
f"The bitmap alias '{alias}' is longer than 255 "
|
|
f"bytes")
|
|
|
|
def test_bitmap_name_too_long(self) -> None:
|
|
name = 'a' * 256
|
|
|
|
self.vm_a.cmd('block-dirty-bitmap-add',
|
|
node=self.src_node_name,
|
|
name=name)
|
|
|
|
self.migrate(False, False)
|
|
|
|
# Check for the error in the source's log
|
|
self.vm_a.shutdown()
|
|
|
|
log = self.vm_a.get_log()
|
|
assert log is not None # Loaded after shutdown
|
|
|
|
self.assertIn(f"Cannot migrate bitmap '{name}' on node "
|
|
f"'{self.src_node_name}': Name is longer than 255 bytes",
|
|
log)
|
|
|
|
# Destination VM will terminate w/ error of its own accord
|
|
# due to the failed migration.
|
|
self.vm_b.wait()
|
|
rc = self.vm_b.exitcode()
|
|
assert rc is not None and rc > 0
|
|
|
|
def test_aliased_bitmap_name_too_long(self) -> None:
|
|
# Longer than the maximum for bitmap names
|
|
self.dst_bmap_name = 'a' * 1024
|
|
|
|
mapping = self.mapping(self.dst_node_name, self.src_node_name,
|
|
self.dst_bmap_name, self.src_bmap_name)
|
|
|
|
# We would have to create this bitmap during migration, and
|
|
# that would fail, because the name is too long. Better to
|
|
# catch it early.
|
|
self.set_mapping(self.vm_b, mapping,
|
|
f"Invalid mapping given for block-bitmap-mapping: "
|
|
f"The bitmap name '{self.dst_bmap_name}' is longer "
|
|
f"than 1023 bytes")
|
|
|
|
def test_node_name_too_long(self) -> None:
|
|
# Longer than the maximum for node names
|
|
self.dst_node_name = 'a' * 32
|
|
|
|
mapping = self.mapping(self.dst_node_name, self.src_node_name,
|
|
self.dst_bmap_name, self.src_bmap_name)
|
|
|
|
# During migration, this would appear simply as a node that
|
|
# cannot be found. Still better to catch impossible node
|
|
# names early (similar to test_non_wellformed_node_alias).
|
|
self.set_mapping(self.vm_b, mapping,
|
|
f"Invalid mapping given for block-bitmap-mapping: "
|
|
f"The node name '{self.dst_node_name}' is longer "
|
|
f"than 31 bytes")
|
|
|
|
|
|
class TestCrossAliasMigration(TestDirtyBitmapMigration):
|
|
"""
|
|
Swap aliases, both to see that qemu does not get confused, and
|
|
that we can migrate multiple things at once.
|
|
|
|
So we migrate this:
|
|
node-a.bmap-a -> node-b.bmap-b
|
|
node-a.bmap-b -> node-b.bmap-a
|
|
node-b.bmap-a -> node-a.bmap-b
|
|
node-b.bmap-b -> node-a.bmap-a
|
|
"""
|
|
|
|
src_node_name = 'node-a'
|
|
dst_node_name = 'node-b'
|
|
src_bmap_name = 'bmap-a'
|
|
dst_bmap_name = 'bmap-b'
|
|
|
|
def setUp(self) -> None:
|
|
TestDirtyBitmapMigration.setUp(self)
|
|
|
|
# Now create another block device and let both have two bitmaps each
|
|
self.vm_a.cmd('blockdev-add',
|
|
node_name='node-b', driver='null-co')
|
|
|
|
self.vm_b.cmd('blockdev-add',
|
|
node_name='node-a', driver='null-co')
|
|
|
|
bmaps_to_add = (('node-a', 'bmap-b'),
|
|
('node-b', 'bmap-a'),
|
|
('node-b', 'bmap-b'))
|
|
|
|
for (node, bmap) in bmaps_to_add:
|
|
self.vm_a.cmd('block-dirty-bitmap-add',
|
|
node=node, name=bmap)
|
|
|
|
@staticmethod
|
|
def cross_mapping() -> BlockBitmapMapping:
|
|
return [
|
|
{
|
|
'node-name': 'node-a',
|
|
'alias': 'node-b',
|
|
'bitmaps': [
|
|
{
|
|
'name': 'bmap-a',
|
|
'alias': 'bmap-b'
|
|
},
|
|
{
|
|
'name': 'bmap-b',
|
|
'alias': 'bmap-a'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
'node-name': 'node-b',
|
|
'alias': 'node-a',
|
|
'bitmaps': [
|
|
{
|
|
'name': 'bmap-b',
|
|
'alias': 'bmap-a'
|
|
},
|
|
{
|
|
'name': 'bmap-a',
|
|
'alias': 'bmap-b'
|
|
}
|
|
]
|
|
}
|
|
]
|
|
|
|
def verify_dest_has_all_bitmaps(self) -> None:
|
|
bitmaps = self.vm_b.query_bitmaps()
|
|
|
|
# Extract and sort bitmap names
|
|
for node in bitmaps:
|
|
bitmaps[node] = sorted((bmap['name'] for bmap in bitmaps[node]))
|
|
|
|
self.assertEqual(bitmaps,
|
|
{'node-a': ['bmap-a', 'bmap-b'],
|
|
'node-b': ['bmap-a', 'bmap-b']})
|
|
|
|
def test_alias_on_src(self) -> None:
|
|
self.set_mapping(self.vm_a, self.cross_mapping())
|
|
|
|
# Checks that node-a.bmap-a was migrated to node-b.bmap-b, and
|
|
# that is enough
|
|
self.migrate()
|
|
self.verify_dest_has_all_bitmaps()
|
|
self.verify_dest_error(None)
|
|
|
|
def test_alias_on_dst(self) -> None:
|
|
self.set_mapping(self.vm_b, self.cross_mapping())
|
|
|
|
# Checks that node-a.bmap-a was migrated to node-b.bmap-b, and
|
|
# that is enough
|
|
self.migrate()
|
|
self.verify_dest_has_all_bitmaps()
|
|
self.verify_dest_error(None)
|
|
|
|
class TestAliasTransformMigration(TestDirtyBitmapMigration):
|
|
"""
|
|
Tests the 'transform' option which modifies bitmap persistence on
|
|
migration.
|
|
"""
|
|
|
|
src_node_name = 'node-a'
|
|
dst_node_name = 'node-b'
|
|
src_bmap_name = 'bmap-a'
|
|
dst_bmap_name = 'bmap-b'
|
|
|
|
def setUp(self) -> None:
|
|
TestDirtyBitmapMigration.setUp(self)
|
|
|
|
# Now create another block device and let both have two bitmaps each
|
|
self.vm_a.cmd('blockdev-add',
|
|
node_name='node-b', driver='null-co',
|
|
read_zeroes=False)
|
|
|
|
self.vm_b.cmd('blockdev-add',
|
|
node_name='node-a', driver='null-co',
|
|
read_zeroes=False)
|
|
|
|
bmaps_to_add = (('node-a', 'bmap-b'),
|
|
('node-b', 'bmap-a'),
|
|
('node-b', 'bmap-b'))
|
|
|
|
for (node, bmap) in bmaps_to_add:
|
|
self.vm_a.cmd('block-dirty-bitmap-add',
|
|
node=node, name=bmap)
|
|
|
|
@staticmethod
|
|
def transform_mapping() -> BlockBitmapMapping:
|
|
return [
|
|
{
|
|
'node-name': 'node-a',
|
|
'alias': 'node-a',
|
|
'bitmaps': [
|
|
{
|
|
'name': 'bmap-a',
|
|
'alias': 'bmap-a',
|
|
'transform':
|
|
{
|
|
'persistent': True
|
|
}
|
|
},
|
|
{
|
|
'name': 'bmap-b',
|
|
'alias': 'bmap-b'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
'node-name': 'node-b',
|
|
'alias': 'node-b',
|
|
'bitmaps': [
|
|
{
|
|
'name': 'bmap-a',
|
|
'alias': 'bmap-a'
|
|
},
|
|
{
|
|
'name': 'bmap-b',
|
|
'alias': 'bmap-b'
|
|
}
|
|
]
|
|
}
|
|
]
|
|
|
|
def verify_dest_bitmap_state(self) -> None:
|
|
bitmaps = self.vm_b.query_bitmaps()
|
|
|
|
for node in bitmaps:
|
|
bitmaps[node] = sorted(((bmap['name'], bmap['persistent'])
|
|
for bmap in bitmaps[node]))
|
|
|
|
self.assertEqual(bitmaps,
|
|
{'node-a': [('bmap-a', True), ('bmap-b', False)],
|
|
'node-b': [('bmap-a', False), ('bmap-b', False)]})
|
|
|
|
def test_transform_on_src(self) -> None:
|
|
self.set_mapping(self.vm_a, self.transform_mapping())
|
|
|
|
self.migrate()
|
|
self.verify_dest_bitmap_state()
|
|
self.verify_dest_error(None)
|
|
|
|
def test_transform_on_dst(self) -> None:
|
|
self.set_mapping(self.vm_b, self.transform_mapping())
|
|
|
|
self.migrate()
|
|
self.verify_dest_bitmap_state()
|
|
self.verify_dest_error(None)
|
|
|
|
if __name__ == '__main__':
|
|
iotests.main(supported_protocols=['file'])
|