9d64a827b9
The following patch allows an empty volume to be created and attached to an instance at boot time. Today, you can define a bootable volume that is sourced from an image, volume, or snapshot. However, you cannot define a volume that is sourced from 'blank', even though it is one of the source options available. For example, the following command will not work: nova boot --flavor m1.tiny --block-device source=blank,dest=volume,size=1,bootindex=0 test. This is because the method used to identify ephemeral volumes (new_format_is_ephemeral) believes any block device with source_type=blank is an ephemeral, and there is no logic to handle volumes where source_type=blank. The following patch fixes these bugs by properly identifying ephemeral block devices and creating blank/empty volumes when source_type=blank and destination_type=volume. Change-Id: I5aa9684bfad1749fadff3018b13a225ed8f16fe8 Closes-Bug: #1347028 Closes-Bug: #1347499
605 lines
25 KiB
Python
605 lines
25 KiB
Python
# Copyright 2011 Isaku Yamahata
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
"""
|
|
Tests for Block Device utility functions.
|
|
"""
|
|
|
|
from nova import block_device
|
|
from nova import exception
|
|
from nova import objects
|
|
from nova import test
|
|
from nova.tests import fake_block_device
|
|
from nova.tests import matchers
|
|
|
|
|
|
class BlockDeviceTestCase(test.NoDBTestCase):
|
|
def setUp(self):
|
|
super(BlockDeviceTestCase, self).setUp()
|
|
BDM = block_device.BlockDeviceDict
|
|
|
|
self.new_mapping = [
|
|
BDM({'id': 1, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sdb1',
|
|
'source_type': 'blank',
|
|
'destination_type': 'local',
|
|
'delete_on_termination': True,
|
|
'volume_size': 1,
|
|
'guest_format': 'swap',
|
|
'boot_index': -1}),
|
|
BDM({'id': 2, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sdc1',
|
|
'source_type': 'blank',
|
|
'destination_type': 'local',
|
|
'volume_size': 10,
|
|
'delete_on_termination': True,
|
|
'boot_index': -1}),
|
|
BDM({'id': 3, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sda1',
|
|
'source_type': 'volume',
|
|
'destination_type': 'volume',
|
|
'volume_id': 'fake-volume-id-1',
|
|
'connection_info': "{'fake': 'connection_info'}",
|
|
'boot_index': 0}),
|
|
BDM({'id': 4, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sda2',
|
|
'source_type': 'snapshot',
|
|
'destination_type': 'volume',
|
|
'connection_info': "{'fake': 'connection_info'}",
|
|
'snapshot_id': 'fake-snapshot-id-1',
|
|
'volume_id': 'fake-volume-id-2',
|
|
'boot_index': -1}),
|
|
BDM({'id': 5, 'instance_uuid': 'fake-instance',
|
|
'no_device': True,
|
|
'device_name': '/dev/vdc'}),
|
|
]
|
|
|
|
def test_properties(self):
|
|
root_device0 = '/dev/sda'
|
|
root_device1 = '/dev/sdb'
|
|
mappings = [{'virtual': 'root',
|
|
'device': root_device0}]
|
|
|
|
properties0 = {'mappings': mappings}
|
|
properties1 = {'mappings': mappings,
|
|
'root_device_name': root_device1}
|
|
|
|
self.assertIsNone(block_device.properties_root_device_name({}))
|
|
self.assertEqual(
|
|
block_device.properties_root_device_name(properties0),
|
|
root_device0)
|
|
self.assertEqual(
|
|
block_device.properties_root_device_name(properties1),
|
|
root_device1)
|
|
|
|
def test_ephemeral(self):
|
|
self.assertFalse(block_device.is_ephemeral('ephemeral'))
|
|
self.assertTrue(block_device.is_ephemeral('ephemeral0'))
|
|
self.assertTrue(block_device.is_ephemeral('ephemeral1'))
|
|
self.assertTrue(block_device.is_ephemeral('ephemeral11'))
|
|
self.assertFalse(block_device.is_ephemeral('root'))
|
|
self.assertFalse(block_device.is_ephemeral('swap'))
|
|
self.assertFalse(block_device.is_ephemeral('/dev/sda1'))
|
|
|
|
self.assertEqual(block_device.ephemeral_num('ephemeral0'), 0)
|
|
self.assertEqual(block_device.ephemeral_num('ephemeral1'), 1)
|
|
self.assertEqual(block_device.ephemeral_num('ephemeral11'), 11)
|
|
|
|
self.assertFalse(block_device.is_swap_or_ephemeral('ephemeral'))
|
|
self.assertTrue(block_device.is_swap_or_ephemeral('ephemeral0'))
|
|
self.assertTrue(block_device.is_swap_or_ephemeral('ephemeral1'))
|
|
self.assertTrue(block_device.is_swap_or_ephemeral('swap'))
|
|
self.assertFalse(block_device.is_swap_or_ephemeral('root'))
|
|
self.assertFalse(block_device.is_swap_or_ephemeral('/dev/sda1'))
|
|
|
|
def test_mappings_prepend_dev(self):
|
|
mapping = [
|
|
{'virtual': 'ami', 'device': '/dev/sda'},
|
|
{'virtual': 'root', 'device': 'sda'},
|
|
{'virtual': 'ephemeral0', 'device': 'sdb'},
|
|
{'virtual': 'swap', 'device': 'sdc'},
|
|
{'virtual': 'ephemeral1', 'device': 'sdd'},
|
|
{'virtual': 'ephemeral2', 'device': 'sde'}]
|
|
|
|
expected = [
|
|
{'virtual': 'ami', 'device': '/dev/sda'},
|
|
{'virtual': 'root', 'device': 'sda'},
|
|
{'virtual': 'ephemeral0', 'device': '/dev/sdb'},
|
|
{'virtual': 'swap', 'device': '/dev/sdc'},
|
|
{'virtual': 'ephemeral1', 'device': '/dev/sdd'},
|
|
{'virtual': 'ephemeral2', 'device': '/dev/sde'}]
|
|
|
|
prepended = block_device.mappings_prepend_dev(mapping)
|
|
self.assertEqual(prepended.sort(), expected.sort())
|
|
|
|
def test_strip_dev(self):
|
|
self.assertEqual(block_device.strip_dev('/dev/sda'), 'sda')
|
|
self.assertEqual(block_device.strip_dev('sda'), 'sda')
|
|
|
|
def test_strip_prefix(self):
|
|
self.assertEqual(block_device.strip_prefix('/dev/sda'), 'a')
|
|
self.assertEqual(block_device.strip_prefix('a'), 'a')
|
|
self.assertEqual(block_device.strip_prefix('xvda'), 'a')
|
|
self.assertEqual(block_device.strip_prefix('vda'), 'a')
|
|
|
|
def test_get_device_letter(self):
|
|
self.assertEqual(block_device.get_device_letter(''), '')
|
|
self.assertEqual(block_device.get_device_letter('/dev/sda1'), 'a')
|
|
self.assertEqual(block_device.get_device_letter('/dev/xvdb'), 'b')
|
|
self.assertEqual(block_device.get_device_letter('/dev/d'), 'd')
|
|
self.assertEqual(block_device.get_device_letter('a'), 'a')
|
|
self.assertEqual(block_device.get_device_letter('sdb2'), 'b')
|
|
self.assertEqual(block_device.get_device_letter('vdc'), 'c')
|
|
|
|
def test_volume_in_mapping(self):
|
|
swap = {'device_name': '/dev/sdb',
|
|
'swap_size': 1}
|
|
ephemerals = [{'num': 0,
|
|
'virtual_name': 'ephemeral0',
|
|
'device_name': '/dev/sdc1',
|
|
'size': 1},
|
|
{'num': 2,
|
|
'virtual_name': 'ephemeral2',
|
|
'device_name': '/dev/sdd',
|
|
'size': 1}]
|
|
block_device_mapping = [{'mount_device': '/dev/sde',
|
|
'device_path': 'fake_device'},
|
|
{'mount_device': '/dev/sdf',
|
|
'device_path': 'fake_device'}]
|
|
block_device_info = {
|
|
'root_device_name': '/dev/sda',
|
|
'swap': swap,
|
|
'ephemerals': ephemerals,
|
|
'block_device_mapping': block_device_mapping}
|
|
|
|
def _assert_volume_in_mapping(device_name, true_or_false):
|
|
in_mapping = block_device.volume_in_mapping(
|
|
device_name, block_device_info)
|
|
self.assertEqual(in_mapping, true_or_false)
|
|
|
|
_assert_volume_in_mapping('sda', False)
|
|
_assert_volume_in_mapping('sdb', True)
|
|
_assert_volume_in_mapping('sdc1', True)
|
|
_assert_volume_in_mapping('sdd', True)
|
|
_assert_volume_in_mapping('sde', True)
|
|
_assert_volume_in_mapping('sdf', True)
|
|
_assert_volume_in_mapping('sdg', False)
|
|
_assert_volume_in_mapping('sdh1', False)
|
|
|
|
def test_get_root_bdm(self):
|
|
root_bdm = {'device_name': 'vda', 'boot_index': 0}
|
|
bdms = [root_bdm,
|
|
{'device_name': 'vdb', 'boot_index': 1},
|
|
{'device_name': 'vdc', 'boot_index': -1},
|
|
{'device_name': 'vdd'}]
|
|
self.assertEqual(root_bdm, block_device.get_root_bdm(bdms))
|
|
self.assertEqual(root_bdm, block_device.get_root_bdm([bdms[0]]))
|
|
self.assertIsNone(block_device.get_root_bdm(bdms[1:]))
|
|
self.assertIsNone(block_device.get_root_bdm(bdms[2:]))
|
|
self.assertIsNone(block_device.get_root_bdm(bdms[3:]))
|
|
self.assertIsNone(block_device.get_root_bdm([]))
|
|
|
|
def test_get_bdm_ephemeral_disk_size(self):
|
|
size = block_device.get_bdm_ephemeral_disk_size(self.new_mapping)
|
|
self.assertEqual(10, size)
|
|
|
|
def test_get_bdm_swap_list(self):
|
|
swap_list = block_device.get_bdm_swap_list(self.new_mapping)
|
|
self.assertEqual(1, len(swap_list))
|
|
self.assertEqual(1, swap_list[0].get('id'))
|
|
|
|
def test_get_bdm_local_disk_num(self):
|
|
size = block_device.get_bdm_local_disk_num(self.new_mapping)
|
|
self.assertEqual(2, size)
|
|
|
|
def test_new_format_is_swap(self):
|
|
expected_results = [True, False, False, False, False]
|
|
for expected, bdm in zip(expected_results, self.new_mapping):
|
|
res = block_device.new_format_is_swap(bdm)
|
|
self.assertEqual(expected, res)
|
|
|
|
def test_new_format_is_ephemeral(self):
|
|
expected_results = [False, True, False, False, False]
|
|
for expected, bdm in zip(expected_results, self.new_mapping):
|
|
res = block_device.new_format_is_ephemeral(bdm)
|
|
self.assertEqual(expected, res)
|
|
|
|
def test_validate_device_name(self):
|
|
for value in [' ', 10, None, 'a' * 260]:
|
|
self.assertRaises(exception.InvalidBDMFormat,
|
|
block_device.validate_device_name,
|
|
value)
|
|
|
|
def test_validate_and_default_volume_size(self):
|
|
bdm = {}
|
|
for value in [-1, 'a', 2.5]:
|
|
bdm['volume_size'] = value
|
|
self.assertRaises(exception.InvalidBDMFormat,
|
|
block_device.validate_and_default_volume_size,
|
|
bdm)
|
|
|
|
def test_get_bdms_to_connect(self):
|
|
root_bdm = {'device_name': 'vda', 'boot_index': 0}
|
|
bdms = [root_bdm,
|
|
{'device_name': 'vdb', 'boot_index': 1},
|
|
{'device_name': 'vdc', 'boot_index': -1},
|
|
{'device_name': 'vde', 'boot_index': None},
|
|
{'device_name': 'vdd'}]
|
|
self.assertNotIn(root_bdm, block_device.get_bdms_to_connect(bdms,
|
|
exclude_root_mapping=True))
|
|
self.assertIn(root_bdm, block_device.get_bdms_to_connect(bdms))
|
|
|
|
|
|
class TestBlockDeviceDict(test.NoDBTestCase):
|
|
def setUp(self):
|
|
super(TestBlockDeviceDict, self).setUp()
|
|
|
|
BDM = block_device.BlockDeviceDict
|
|
|
|
self.api_mapping = [
|
|
{'id': 1, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sdb1',
|
|
'source_type': 'blank',
|
|
'destination_type': 'local',
|
|
'delete_on_termination': True,
|
|
'guest_format': 'swap',
|
|
'boot_index': -1},
|
|
{'id': 2, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sdc1',
|
|
'source_type': 'blank',
|
|
'destination_type': 'local',
|
|
'delete_on_termination': True,
|
|
'boot_index': -1},
|
|
{'id': 3, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sda1',
|
|
'source_type': 'volume',
|
|
'destination_type': 'volume',
|
|
'uuid': 'fake-volume-id-1',
|
|
'boot_index': 0},
|
|
{'id': 4, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sda2',
|
|
'source_type': 'snapshot',
|
|
'destination_type': 'volume',
|
|
'uuid': 'fake-snapshot-id-1',
|
|
'boot_index': -1},
|
|
{'id': 5, 'instance_uuid': 'fake-instance',
|
|
'no_device': True,
|
|
'device_name': '/dev/vdc'},
|
|
]
|
|
|
|
self.new_mapping = [
|
|
BDM({'id': 1, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sdb1',
|
|
'source_type': 'blank',
|
|
'destination_type': 'local',
|
|
'delete_on_termination': True,
|
|
'guest_format': 'swap',
|
|
'boot_index': -1}),
|
|
BDM({'id': 2, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sdc1',
|
|
'source_type': 'blank',
|
|
'destination_type': 'local',
|
|
'delete_on_termination': True,
|
|
'boot_index': -1}),
|
|
BDM({'id': 3, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sda1',
|
|
'source_type': 'volume',
|
|
'destination_type': 'volume',
|
|
'volume_id': 'fake-volume-id-1',
|
|
'connection_info': "{'fake': 'connection_info'}",
|
|
'boot_index': 0}),
|
|
BDM({'id': 4, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sda2',
|
|
'source_type': 'snapshot',
|
|
'destination_type': 'volume',
|
|
'connection_info': "{'fake': 'connection_info'}",
|
|
'snapshot_id': 'fake-snapshot-id-1',
|
|
'volume_id': 'fake-volume-id-2',
|
|
'boot_index': -1}),
|
|
BDM({'id': 5, 'instance_uuid': 'fake-instance',
|
|
'no_device': True,
|
|
'device_name': '/dev/vdc'}),
|
|
]
|
|
|
|
self.legacy_mapping = [
|
|
{'id': 1, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sdb1',
|
|
'delete_on_termination': True,
|
|
'virtual_name': 'swap'},
|
|
{'id': 2, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sdc1',
|
|
'delete_on_termination': True,
|
|
'virtual_name': 'ephemeral0'},
|
|
{'id': 3, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sda1',
|
|
'volume_id': 'fake-volume-id-1',
|
|
'connection_info': "{'fake': 'connection_info'}"},
|
|
{'id': 4, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sda2',
|
|
'connection_info': "{'fake': 'connection_info'}",
|
|
'snapshot_id': 'fake-snapshot-id-1',
|
|
'volume_id': 'fake-volume-id-2'},
|
|
{'id': 5, 'instance_uuid': 'fake-instance',
|
|
'no_device': True,
|
|
'device_name': '/dev/vdc'},
|
|
]
|
|
|
|
self.new_mapping_source_image = [
|
|
BDM({'id': 6, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sda3',
|
|
'source_type': 'image',
|
|
'destination_type': 'volume',
|
|
'connection_info': "{'fake': 'connection_info'}",
|
|
'volume_id': 'fake-volume-id-3',
|
|
'boot_index': -1}),
|
|
BDM({'id': 7, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sda4',
|
|
'source_type': 'image',
|
|
'destination_type': 'local',
|
|
'connection_info': "{'fake': 'connection_info'}",
|
|
'image_id': 'fake-image-id-2',
|
|
'boot_index': -1}),
|
|
]
|
|
|
|
self.legacy_mapping_source_image = [
|
|
{'id': 6, 'instance_uuid': 'fake-instance',
|
|
'device_name': '/dev/sda3',
|
|
'connection_info': "{'fake': 'connection_info'}",
|
|
'volume_id': 'fake-volume-id-3'},
|
|
]
|
|
|
|
def test_init(self):
|
|
def fake_validate(obj, dct):
|
|
pass
|
|
|
|
self.stubs.Set(block_device.BlockDeviceDict, '_fields',
|
|
set(['field1', 'field2']))
|
|
self.stubs.Set(block_device.BlockDeviceDict, '_db_only_fields',
|
|
set(['db_field1', 'db_field2']))
|
|
self.stubs.Set(block_device.BlockDeviceDict, '_validate',
|
|
fake_validate)
|
|
|
|
# Make sure db fields are not picked up if they are not
|
|
# in the original dict
|
|
dev_dict = block_device.BlockDeviceDict({'field1': 'foo',
|
|
'field2': 'bar',
|
|
'db_field1': 'baz'})
|
|
self.assertIn('field1', dev_dict)
|
|
self.assertIn('field2', dev_dict)
|
|
self.assertIn('db_field1', dev_dict)
|
|
self.assertNotIn('db_field2', dev_dict)
|
|
|
|
# Make sure all expected fields are defaulted
|
|
dev_dict = block_device.BlockDeviceDict({'field1': 'foo'})
|
|
self.assertIn('field1', dev_dict)
|
|
self.assertIn('field2', dev_dict)
|
|
self.assertIsNone(dev_dict['field2'])
|
|
self.assertNotIn('db_field1', dev_dict)
|
|
self.assertNotIn('db_field2', dev_dict)
|
|
|
|
# Unless they are not meant to be
|
|
dev_dict = block_device.BlockDeviceDict({'field1': 'foo'},
|
|
do_not_default=set(['field2']))
|
|
self.assertIn('field1', dev_dict)
|
|
self.assertNotIn('field2', dev_dict)
|
|
self.assertNotIn('db_field1', dev_dict)
|
|
self.assertNotIn('db_field2', dev_dict)
|
|
|
|
# Passing kwargs to constructor works
|
|
dev_dict = block_device.BlockDeviceDict(field1='foo')
|
|
self.assertIn('field1', dev_dict)
|
|
self.assertIn('field2', dev_dict)
|
|
self.assertIsNone(dev_dict['field2'])
|
|
dev_dict = block_device.BlockDeviceDict(
|
|
{'field1': 'foo'}, field2='bar')
|
|
self.assertEqual('foo', dev_dict['field1'])
|
|
self.assertEqual('bar', dev_dict['field2'])
|
|
|
|
def test_init_prepend_dev_to_device_name(self):
|
|
bdm = {'id': 3, 'instance_uuid': 'fake-instance',
|
|
'device_name': 'vda',
|
|
'source_type': 'volume',
|
|
'destination_type': 'volume',
|
|
'volume_id': 'fake-volume-id-1',
|
|
'boot_index': 0}
|
|
bdm_dict = block_device.BlockDeviceDict(bdm)
|
|
self.assertEqual('/dev/vda', bdm_dict['device_name'])
|
|
|
|
bdm['device_name'] = '/dev/vdb'
|
|
bdm_dict = block_device.BlockDeviceDict(bdm)
|
|
self.assertEqual('/dev/vdb', bdm_dict['device_name'])
|
|
|
|
bdm['device_name'] = None
|
|
bdm_dict = block_device.BlockDeviceDict(bdm)
|
|
self.assertIsNone(bdm_dict['device_name'])
|
|
|
|
def test_validate(self):
|
|
self.assertRaises(exception.InvalidBDMFormat,
|
|
block_device.BlockDeviceDict,
|
|
{'bogus_field': 'lame_val'})
|
|
|
|
lame_bdm = dict(self.new_mapping[2])
|
|
del lame_bdm['source_type']
|
|
self.assertRaises(exception.InvalidBDMFormat,
|
|
block_device.BlockDeviceDict,
|
|
lame_bdm)
|
|
|
|
lame_bdm['no_device'] = True
|
|
block_device.BlockDeviceDict(lame_bdm)
|
|
|
|
lame_dev_bdm = dict(self.new_mapping[2])
|
|
lame_dev_bdm['device_name'] = "not a valid name"
|
|
self.assertRaises(exception.InvalidBDMFormat,
|
|
block_device.BlockDeviceDict,
|
|
lame_dev_bdm)
|
|
|
|
lame_dev_bdm['device_name'] = ""
|
|
self.assertRaises(exception.InvalidBDMFormat,
|
|
block_device.BlockDeviceDict,
|
|
lame_dev_bdm)
|
|
|
|
cool_volume_size_bdm = dict(self.new_mapping[2])
|
|
cool_volume_size_bdm['volume_size'] = '42'
|
|
cool_volume_size_bdm = block_device.BlockDeviceDict(
|
|
cool_volume_size_bdm)
|
|
self.assertEqual(cool_volume_size_bdm['volume_size'], 42)
|
|
|
|
lame_volume_size_bdm = dict(self.new_mapping[2])
|
|
lame_volume_size_bdm['volume_size'] = 'some_non_int_string'
|
|
self.assertRaises(exception.InvalidBDMFormat,
|
|
block_device.BlockDeviceDict,
|
|
lame_volume_size_bdm)
|
|
|
|
truthy_bdm = dict(self.new_mapping[2])
|
|
truthy_bdm['delete_on_termination'] = '1'
|
|
truthy_bdm = block_device.BlockDeviceDict(truthy_bdm)
|
|
self.assertEqual(truthy_bdm['delete_on_termination'], True)
|
|
|
|
verbose_bdm = dict(self.new_mapping[2])
|
|
verbose_bdm['boot_index'] = 'first'
|
|
self.assertRaises(exception.InvalidBDMFormat,
|
|
block_device.BlockDeviceDict,
|
|
verbose_bdm)
|
|
|
|
def test_from_legacy(self):
|
|
for legacy, new in zip(self.legacy_mapping, self.new_mapping):
|
|
self.assertThat(
|
|
block_device.BlockDeviceDict.from_legacy(legacy),
|
|
matchers.IsSubDictOf(new))
|
|
|
|
def test_from_legacy_mapping(self):
|
|
def _get_image_bdms(bdms):
|
|
return [bdm for bdm in bdms if bdm['source_type'] == 'image']
|
|
|
|
def _get_bootable_bdms(bdms):
|
|
return [bdm for bdm in bdms if bdm['boot_index'] >= 0]
|
|
|
|
new_no_img = block_device.from_legacy_mapping(self.legacy_mapping)
|
|
self.assertEqual(len(_get_image_bdms(new_no_img)), 0)
|
|
|
|
for new, expected in zip(new_no_img, self.new_mapping):
|
|
self.assertThat(new, matchers.IsSubDictOf(expected))
|
|
|
|
new_with_img = block_device.from_legacy_mapping(
|
|
self.legacy_mapping, 'fake_image_ref')
|
|
image_bdms = _get_image_bdms(new_with_img)
|
|
boot_bdms = _get_bootable_bdms(new_with_img)
|
|
self.assertEqual(len(image_bdms), 1)
|
|
self.assertEqual(len(boot_bdms), 1)
|
|
self.assertEqual(image_bdms[0]['boot_index'], 0)
|
|
self.assertEqual(boot_bdms[0]['source_type'], 'image')
|
|
|
|
new_with_img_and_root = block_device.from_legacy_mapping(
|
|
self.legacy_mapping, 'fake_image_ref', 'sda1')
|
|
image_bdms = _get_image_bdms(new_with_img_and_root)
|
|
boot_bdms = _get_bootable_bdms(new_with_img_and_root)
|
|
self.assertEqual(len(image_bdms), 0)
|
|
self.assertEqual(len(boot_bdms), 1)
|
|
self.assertEqual(boot_bdms[0]['boot_index'], 0)
|
|
self.assertEqual(boot_bdms[0]['source_type'], 'volume')
|
|
|
|
new_no_root = block_device.from_legacy_mapping(
|
|
self.legacy_mapping, 'fake_image_ref', 'sda1', no_root=True)
|
|
self.assertEqual(len(_get_image_bdms(new_no_root)), 0)
|
|
self.assertEqual(len(_get_bootable_bdms(new_no_root)), 0)
|
|
|
|
def test_from_api(self):
|
|
for api, new in zip(self.api_mapping, self.new_mapping):
|
|
new['connection_info'] = None
|
|
if new['snapshot_id']:
|
|
new['volume_id'] = None
|
|
self.assertThat(
|
|
block_device.BlockDeviceDict.from_api(api),
|
|
matchers.IsSubDictOf(new))
|
|
|
|
def test_from_api_invalid_blank_id(self):
|
|
api_dict = {'id': 1,
|
|
'source_type': 'blank',
|
|
'destination_type': 'volume',
|
|
'uuid': 'fake-volume-id-1',
|
|
'delete_on_termination': True,
|
|
'boot_index': -1}
|
|
self.assertRaises(exception.InvalidBDMFormat,
|
|
block_device.BlockDeviceDict.from_api, api_dict)
|
|
|
|
def test_legacy(self):
|
|
for legacy, new in zip(self.legacy_mapping, self.new_mapping):
|
|
self.assertThat(
|
|
legacy,
|
|
matchers.IsSubDictOf(new.legacy()))
|
|
|
|
def test_legacy_mapping(self):
|
|
got_legacy = block_device.legacy_mapping(self.new_mapping)
|
|
|
|
for legacy, expected in zip(got_legacy, self.legacy_mapping):
|
|
self.assertThat(expected, matchers.IsSubDictOf(legacy))
|
|
|
|
def test_legacy_source_image(self):
|
|
for legacy, new in zip(self.legacy_mapping_source_image,
|
|
self.new_mapping_source_image):
|
|
if new['destination_type'] == 'volume':
|
|
self.assertThat(legacy, matchers.IsSubDictOf(new.legacy()))
|
|
else:
|
|
self.assertRaises(exception.InvalidBDMForLegacy, new.legacy)
|
|
|
|
def test_legacy_mapping_source_image(self):
|
|
got_legacy = block_device.legacy_mapping(self.new_mapping)
|
|
|
|
for legacy, expected in zip(got_legacy, self.legacy_mapping):
|
|
self.assertThat(expected, matchers.IsSubDictOf(legacy))
|
|
|
|
def test_legacy_mapping_from_object_list(self):
|
|
bdm1 = objects.BlockDeviceMapping()
|
|
bdm1 = objects.BlockDeviceMapping._from_db_object(
|
|
None, bdm1, fake_block_device.FakeDbBlockDeviceDict(
|
|
self.new_mapping[0]))
|
|
bdm2 = objects.BlockDeviceMapping()
|
|
bdm2 = objects.BlockDeviceMapping._from_db_object(
|
|
None, bdm2, fake_block_device.FakeDbBlockDeviceDict(
|
|
self.new_mapping[1]))
|
|
bdmlist = objects.BlockDeviceMappingList()
|
|
bdmlist.objects = [bdm1, bdm2]
|
|
block_device.legacy_mapping(bdmlist)
|
|
|
|
def test_image_mapping(self):
|
|
removed_fields = ['id', 'instance_uuid', 'connection_info',
|
|
'device_name', 'created_at', 'updated_at',
|
|
'deleted_at', 'deleted']
|
|
for bdm in self.new_mapping:
|
|
mapping_bdm = fake_block_device.FakeDbBlockDeviceDict(
|
|
bdm).get_image_mapping()
|
|
for fld in removed_fields:
|
|
self.assertNotIn(fld, mapping_bdm)
|
|
|
|
def _test_snapshot_from_bdm(self, template):
|
|
snapshot = block_device.snapshot_from_bdm('new-snapshot-id', template)
|
|
self.assertEqual(snapshot['snapshot_id'], 'new-snapshot-id')
|
|
self.assertEqual(snapshot['source_type'], 'snapshot')
|
|
self.assertEqual(snapshot['destination_type'], 'volume')
|
|
for key in ['disk_bus', 'device_type', 'boot_index']:
|
|
self.assertEqual(snapshot[key], template[key])
|
|
|
|
def test_snapshot_from_bdm(self):
|
|
for bdm in self.new_mapping:
|
|
self._test_snapshot_from_bdm(bdm)
|
|
|
|
def test_snapshot_from_object(self):
|
|
for bdm in self.new_mapping[:-1]:
|
|
obj = objects.BlockDeviceMapping()
|
|
obj = objects.BlockDeviceMapping._from_db_object(
|
|
None, obj, fake_block_device.FakeDbBlockDeviceDict(
|
|
bdm))
|
|
self._test_snapshot_from_bdm(obj)
|