def test_boot_partition_ok_many_normal_disks(self, mock_lbd, mock_http_req,
mock_yaml):
data = copy.deepcopy(PROVISION_SAMPLE_DATA)
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
drv = nailgun.Nailgun(data)
self.assertEqual(
drv.partition_scheme.fs_by_mount('/boot').device, '/dev/sda3')
def test_parse_operating_system_test_profiles(self, mock_nailgun):
d = {
'centos-x86_64': {
'obj': objects.Centos,
'minor': 5,
'major': 6
},
'centos7-x86_64': {
'obj': objects.Centos,
'minor': 0,
'major': 7
},
'ubuntu_1204_x86_64': {
'obj': objects.Ubuntu,
'minor': 4,
'major': 12
},
'ubuntu_1404_x86_64': {
'obj': objects.Ubuntu,
'minor': 4,
'major': 14
},
'generic_os': {
'obj': objects.OperatingSystem,
'minor': 'unknown',
'major': 'unknown'
}
}
drv = nailgun.Nailgun('fake_data')
for profile, obj in six.iteritems(d):
os = drv.get_os_by_profile(profile)
self.assertIsInstance(os, obj['obj'])
self.assertEqual(obj['minor'], os.minor)
self.assertEqual(obj['major'], os.major)
def test_boot_partition_is_not_on_nvme(self, mock_lbd, mock_image_meta):
data = copy.deepcopy(PROVISION_SAMPLE_DATA)
data['ks_meta']['pm_data']['ks_spaces'] = FIRST_DISK_NVME_KS_SPACES
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE_NVME
drv = nailgun.Nailgun(data)
self.assertEqual(
drv.partition_scheme.fs_by_mount('/boot').device, '/dev/sda3')
def test_elevate_keep_data_single_disk(self, mock_lbd, mock_image_meta):
data = copy.deepcopy(PROVISION_SAMPLE_DATA)
data['ks_meta']['pm_data']['ks_spaces'] = SINGLE_DISK_KS_SPACES
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
drv = nailgun.Nailgun(data)
self.assertTrue(drv.partition_scheme.fs_by_mount('/').keep_data)
for parted in drv.partition_scheme.parteds:
for partition in parted.partitions:
self.assertFalse(partition.keep_data)
for md in drv.partition_scheme.mds:
self.assertFalse(md.keep_data)
for pv in drv.partition_scheme.pvs:
self.assertFalse(pv.keep_data)
for vg in drv.partition_scheme.vgs:
self.assertFalse(vg.keep_data)
for lv in drv.partition_scheme.lvs:
self.assertFalse(lv.keep_data)
for fs in drv.partition_scheme.fss:
if fs.mount != '/':
self.assertFalse(fs.keep_data)
def test_getlabel(self, mock_lbd, mock_http_req, mock_yaml):
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
drv = nailgun.Nailgun(PROVISION_SAMPLE_DATA)
self.assertEqual('', drv._getlabel(None))
long_label = '1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ'
self.assertEqual(' -L %s ' % long_label[:12],
drv._getlabel(long_label))
def test_image_scheme(self, mock_lbd, mock_http_req, mock_yaml):
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
drv = nailgun.Nailgun(PROVISION_SAMPLE_DATA)
p_scheme = drv.partition_scheme
i_scheme = drv.image_scheme
expected_images = []
for fs in p_scheme.fss:
if fs.mount not in PROVISION_SAMPLE_DATA['ks_meta']['image_data']:
continue
i_data = PROVISION_SAMPLE_DATA['ks_meta']['image_data'][fs.mount]
expected_images.append(
image.Image(
uri=i_data['uri'],
target_device=fs.device,
format=i_data['format'],
container=i_data['container'],
))
expected_images = sorted(expected_images, key=lambda x: x.uri)
for i, img in enumerate(sorted(i_scheme.images, key=lambda x: x.uri)):
self.assertEqual(img.uri, expected_images[i].uri)
self.assertEqual(img.target_device,
expected_images[i].target_device)
self.assertEqual(img.format, expected_images[i].format)
self.assertEqual(img.container, expected_images[i].container)
self.assertIsNone(img.size)
self.assertIsNone(img.md5)
def test_boot_partition_no_boot_nvme(self, mock_lbd, mock_image_meta):
data = copy.deepcopy(PROVISION_SAMPLE_DATA)
data['ks_meta']['pm_data']['ks_spaces'] = ONLY_ONE_NVME_KS_SPACES
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE_NVME
with self.assertRaisesRegexp(
errors.WrongPartitionSchemeError,
'/boot partition has not been created for some reasons'):
nailgun.Nailgun(data)
def test_boot_partition_ok_many_huge_disks(self, mock_lbd, mock_http_req,
mock_yaml):
data = copy.deepcopy(PROVISION_SAMPLE_DATA)
data['ks_meta']['pm_data']['ks_spaces'] = MANY_HUGE_DISKS_KS_SPACES
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
drv = nailgun.Nailgun(data)
self.assertEqual(
drv.partition_scheme.fs_by_mount('/boot').device, '/dev/sda3')
def test_configdrive_scheme_set_cloud_init_templates(
self, mock_lbd, mock_image_meta):
data = copy.deepcopy(PROVISION_SAMPLE_DATA)
expected_templates = 'fake_templates'
data['ks_meta']['cloud_init_templates'] = expected_templates
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
cd_scheme = nailgun.Nailgun(data).configdrive_scheme
self.assertEqual(expected_templates, cd_scheme.templates)
def test_parse_image_meta_not_parsed(self, mock_lbd, mock_http_req):
mock_http_req.side_effect = KeyError()
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
p_data = PROVISION_SAMPLE_DATA.copy()
drv = nailgun.Nailgun(p_data)
self.assertEqual({}, drv._image_meta)
mock_http_req.assert_called_once_with(
'http://fake.host.org:123/imgs/fake_image.yaml')
def test_md_metadata_ubuntu(self, mock_lbd, mock_image_meta):
data = copy.deepcopy(PROVISION_SAMPLE_DATA)
data['profile'] = 'base-ubuntu_1404_x86_64'
data['ks_meta']['pm_data']['ks_spaces'] = MD_RAID_KS_SPACES
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
drv = nailgun.Nailgun(data)
self.assertEqual(1, len(drv.partition_scheme.mds))
self.assertEqual(2, drv.grub.version)
self.assertEqual('default', drv.partition_scheme.mds[0].metadata)
def test_partition_scheme(self, mock_lbd, mock_http_req, mock_yaml):
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
drv = nailgun.Nailgun(PROVISION_SAMPLE_DATA)
p_scheme = drv.partition_scheme
self.assertEqual(5, len(p_scheme.fss))
self.assertEqual(4, len(p_scheme.pvs))
self.assertEqual(3, len(p_scheme.lvs))
self.assertEqual(2, len(p_scheme.vgs))
self.assertEqual(3, len(p_scheme.parteds))
def test_grub_centos_lt(self, mock_lbd, mock_http_req, mock_yaml):
data = copy.deepcopy(PROVISION_SAMPLE_DATA)
data['profile'] = 'centos'
data['ks_meta']['kernel_lt'] = 1
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
drv = nailgun.Nailgun(data)
self.assertEqual(drv.grub.kernel_params,
' ' + data['ks_meta']['pm_data']['kernel_params'])
self.assertIsNone(drv.grub.kernel_regexp)
self.assertIsNone(drv.grub.initrd_regexp)
self.assertIsNone(drv.grub.version)
self.assertIsNone(drv.grub.kernel_name)
self.assertIsNone(drv.grub.initrd_name)
def test_disk_dev_not_found(self, mock_lbd, mock_http_req, mock_yaml):
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
drv = nailgun.Nailgun(PROVISION_SAMPLE_DATA)
fake_ks_disk = {
"name":
"fake",
"extra": [
"disk/by-id/fake_scsi_matches",
"disk/by-id/fake_ata_dont_matches"
]
}
self.assertRaises(errors.DiskNotFoundError, drv._disk_dev,
fake_ks_disk)
def test_grub_centos_26(self, mock_lbd, mock_image_meta):
data = copy.deepcopy(PROVISION_SAMPLE_DATA)
data['profile'] = 'centos'
data['ks_meta']['kernel_lt'] = 0
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
drv = nailgun.Nailgun(data)
self.assertEqual(drv.grub.kernel_params,
' ' + data['ks_meta']['pm_data']['kernel_params'])
self.assertEqual(drv.grub.kernel_regexp, r'^vmlinuz-2\.6.*')
self.assertEqual(drv.grub.initrd_regexp, r'^initramfs-2\.6.*')
self.assertEqual(1, drv.grub.version)
self.assertIsNone(drv.grub.kernel_name)
self.assertIsNone(drv.grub.initrd_name)
def test_parse_image_meta(self, mock_lbd, mock_http_req):
fake_image_meta = {
'images': [{
'raw_md5': 'fakeroot',
'raw_size': 1,
'container_name': 'fake_image.img.gz'
}]
}
prop_mock = mock.PropertyMock(return_value=yaml.dump(fake_image_meta))
type(mock_http_req.return_value).text = prop_mock
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
p_data = PROVISION_SAMPLE_DATA.copy()
drv = nailgun.Nailgun(p_data)
self.assertEqual(fake_image_meta, drv._image_meta)
mock_http_req.assert_called_once_with(
'http://fake.host.org:123/imgs/fake_image.yaml')
def test_configdrive_scheme(self, mock_lbd, mock_http, mock_yaml):
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
cd_scheme = nailgun.Nailgun(PROVISION_SAMPLE_DATA).configdrive_scheme
self.assertEqual(
['fake_authorized_key1', 'fake_authorized_key2', 'fake_auth_key'],
cd_scheme.common.ssh_auth_keys)
self.assertEqual('node-1.domain.tld', cd_scheme.common.hostname)
self.assertEqual('node-1.domain.tld', cd_scheme.common.fqdn)
self.assertEqual('node-1.domain.tld', cd_scheme.common.fqdn)
self.assertEqual('"10.20.0.2"', cd_scheme.common.name_servers)
self.assertEqual('"domain.tld"', cd_scheme.common.search_domain)
self.assertEqual('10.20.0.2', cd_scheme.common.master_ip)
self.assertEqual('http://10.20.0.2:8000/api',
cd_scheme.common.master_url)
self.assertEqual(
'08:00:27:79:da:80_eth0,08:00:27:46:43:60_eth1,'
'08:00:27:b1:d7:15_eth2', cd_scheme.common.udevrules)
self.assertEqual('08:00:27:79:da:80', cd_scheme.common.admin_mac)
self.assertEqual('10.20.0.3', cd_scheme.common.admin_ip)
self.assertEqual('255.255.255.0', cd_scheme.common.admin_mask)
self.assertEqual('eth0', cd_scheme.common.admin_iface_name)
self.assertEqual('America/Los_Angeles', cd_scheme.common.timezone)
self.assertEqual('fuel.domain.tld', cd_scheme.puppet.master)
self.assertEqual('unset', cd_scheme.mcollective.pskey)
self.assertEqual('mcollective', cd_scheme.mcollective.vhost)
self.assertEqual('10.20.0.2', cd_scheme.mcollective.host)
self.assertEqual('mcollective', cd_scheme.mcollective.user)
self.assertEqual('marionette', cd_scheme.mcollective.password)
self.assertEqual('rabbitmq', cd_scheme.mcollective.connector)
self.assertEqual('pro_fi-le', cd_scheme.profile)
self.assertEqual([{
"name": "repo1",
"type": "deb",
"uri": "uri1",
"suite": "suite",
"section": "section",
"priority": 1001
}, {
"name": "repo2",
"type": "deb",
"uri": "uri2",
"suite": "suite",
"section": "section",
"priority": 1001
}], cd_scheme.common.ks_repos)
def test_parse_operating_system_image_meta(self, mock_nailgun):
d = {
'Centos': objects.Centos,
'Ubuntu': objects.Ubuntu,
'unknown': None
}
drv = nailgun.Nailgun('fake_data')
for os_name, obj in six.iteritems(d):
os = drv.get_os_by_image_meta({
'name': os_name,
'minor': 1,
'major': 2
})
if os:
self.assertIsInstance(os, obj)
self.assertEqual(1, os.minor)
self.assertEqual(2, os.major)
else:
self.assertIsNone(os)
self.assertEqual('unknown', os_name)
def test_partition_scheme_ceph(self, mock_lbd, mock_http_req, mock_yaml):
# TODO(agordeev): perform better testing of ceph logic
p_data = copy.deepcopy(PROVISION_SAMPLE_DATA)
for i in range(0, 3):
p_data['ks_meta']['pm_data']['ks_spaces'][i]['volumes'].append(
CEPH_JOURNAL)
p_data['ks_meta']['pm_data']['ks_spaces'][i]['volumes'].append(
CEPH_DATA)
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
drv = nailgun.Nailgun(p_data)
p_scheme = drv.partition_scheme
self.assertEqual(5, len(p_scheme.fss))
self.assertEqual(4, len(p_scheme.pvs))
self.assertEqual(3, len(p_scheme.lvs))
self.assertEqual(2, len(p_scheme.vgs))
self.assertEqual(3, len(p_scheme.parteds))
self.assertEqual(3, drv._get_partition_count('ceph'))
# NOTE(agordeev): (-2, -1, -1) is the list of ceph data partition
# counts corresponding to (sda, sdb, sdc) disks respectively.
for disk, part in enumerate((-2, -1, -1)):
self.assertEqual(CEPH_DATA['partition_guid'],
p_scheme.parteds[disk].partitions[part].guid)
def test_image_scheme_with_checksums(self, mock_lbd, mock_http_req):
fake_image_meta = {
'images': [{
'raw_md5': 'fakeroot',
'raw_size': 1,
'container_name': 'fake_image.img.gz'
}]
}
prop_mock = mock.PropertyMock(return_value=yaml.dump(fake_image_meta))
type(mock_http_req.return_value).text = prop_mock
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
p_data = PROVISION_SAMPLE_DATA.copy()
drv = nailgun.Nailgun(p_data)
p_scheme = drv.partition_scheme
i_scheme = drv.image_scheme
mock_http_req.assert_called_once_with(
'http://fake.host.org:123/imgs/fake_image.yaml')
expected_images = []
for fs in p_scheme.fss:
if fs.mount not in PROVISION_SAMPLE_DATA['ks_meta']['image_data']:
continue
i_data = PROVISION_SAMPLE_DATA['ks_meta']['image_data'][fs.mount]
expected_images.append(
image.Image(
uri=i_data['uri'],
target_device=fs.device,
format=i_data['format'],
container=i_data['container'],
))
expected_images = sorted(expected_images, key=lambda x: x.uri)
for i, img in enumerate(sorted(i_scheme.images, key=lambda x: x.uri)):
self.assertEqual(img.uri, expected_images[i].uri)
self.assertEqual(img.target_device,
expected_images[i].target_device)
self.assertEqual(img.format, expected_images[i].format)
self.assertEqual(img.container, expected_images[i].container)
self.assertEqual(img.size,
fake_image_meta['images'][0]['raw_size'])
self.assertEqual(img.md5, fake_image_meta['images'][0]['raw_md5'])
def test_image_scheme_with_checksums(self, mock_lbd, mock_image_meta):
fake_image_meta = {
'images': [{
'raw_md5': 'fakeroot',
'raw_size': 1,
'container_name': 'fake_image.img.gz'
}]
}
mock_image_meta.return_value = fake_image_meta
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
p_data = PROVISION_SAMPLE_DATA.copy()
drv = nailgun.Nailgun(p_data)
p_scheme = drv.partition_scheme
i_scheme = drv.image_scheme
expected_images = []
for fs in p_scheme.fss:
if fs.mount not in PROVISION_SAMPLE_DATA['ks_meta']['image_data']:
continue
i_data = PROVISION_SAMPLE_DATA['ks_meta']['image_data'][fs.mount]
expected_images.append(
image.Image(
uri=i_data['uri'],
target_device=fs.device,
format=i_data['format'],
container=i_data['container'],
))
expected_images = sorted(expected_images, key=lambda x: x.uri)
for i, img in enumerate(sorted(i_scheme.images, key=lambda x: x.uri)):
self.assertEqual(img.uri, expected_images[i].uri)
self.assertEqual(img.target_device,
expected_images[i].target_device)
self.assertEqual(img.format, expected_images[i].format)
self.assertEqual(img.container, expected_images[i].container)
self.assertEqual(img.size,
fake_image_meta['images'][0]['raw_size'])
self.assertEqual(img.md5, fake_image_meta['images'][0]['raw_md5'])
def setUp(self):
super(TestNailgun, self).setUp()
self.drv = nailgun.Nailgun(PROVISION_SAMPLE_DATA)
def test_get_partition_count(self, mock_lbd, mock_http_req, mock_yaml):
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
drv = nailgun.Nailgun(PROVISION_SAMPLE_DATA)
self.assertEqual(3, drv._get_partition_count('Boot'))
self.assertEqual(1, drv._get_partition_count('TMP'))
def setUp(self, mock_lbd, mock_http, mock_yaml):
super(TestNailgun, self).setUp()
mock_lbd.return_value = LIST_BLOCK_DEVICES_SAMPLE
self.drv = nailgun.Nailgun(PROVISION_SAMPLE_DATA)
