def get_configuration():
"""Get the current RAID configuration.
Get the RAID configuration from the server and return it
as a dictionary.
:returns: A dictionary of the below format.
raid_config = {
'logical_disks': [{
'size_gb': 100,
'raid_level': 1,
'physical_disks': [
'5I:0:1',
'5I:0:2'],
'controller': 'Smart array controller'
},
]
}
"""
server = objects.Server()
logical_drives = server.get_logical_drives()
raid_config = {}
raid_config['logical_disks'] = []
for logical_drive in logical_drives:
logical_drive_dict = logical_drive.get_logical_drive_dict()
raid_config['logical_disks'].append(logical_drive_dict)
_update_physical_disk_details(raid_config, server)
return raid_config
def test_create_logical_drive_with_raid_array(self, execute_mock,
get_all_details_mock):
get_all_details_mock.return_value = raid_constants.HPSSA_NO_DRIVES
server = objects.Server()
controller = server.controllers[0]
logical_drive_info = {
'size_gb': 50,
'raid_level': '1',
'volume_name': 'boot_volume',
'is_boot_volume': 'true',
'controller': 'Smart Array P822 in Slot 2',
'array': 'A'
}
controller.create_logical_drive(logical_drive_info)
execute_mock.assert_called_once_with("array",
"A",
"create",
"type=logicaldrive",
"raid=1",
"size=51200",
process_input='y')
def test_server_object_no_logical_drives(self, get_all_details_mock):
get_all_details_mock.return_value = raid_constants.HPSSA_NO_DRIVES
server = objects.Server()
# Assertions on server
self.assertEqual(1, len(server.controllers))
# Assertions on RAID controller properties
controller = server.controllers[0]
self.assertEqual(server, controller.parent)
self.assertIsInstance(controller.properties, dict)
self.assertEqual('Smart Array P822 in Slot 2', controller.id)
self.assertEqual(7, len(controller.unassigned_physical_drives))
self.assertFalse(controller.raid_arrays)
# Assertion on physical drives on controller
physical_drives_expected = ['5I:1:1', '5I:1:2', '5I:1:3', '5I:1:4',
'6I:1:5', '6I:1:6', '6I:1:7']
physical_drives_found = map(lambda x: x.id,
controller.unassigned_physical_drives)
self.assertEqual(sorted(physical_drives_expected),
sorted(physical_drives_found))
physical_drive = list(filter(lambda x: x.id == '5I:1:1',
controller.unassigned_physical_drives))[0]
self.assertEqual(controller, physical_drive.parent)
self.assertEqual(500, physical_drive.size_gb)
self.assertEqual(constants.INTERFACE_TYPE_SAS,
physical_drive.interface_type)
self.assertEqual(constants.DISK_TYPE_HDD,
physical_drive.disk_type)
def has_erase_completed():
server = objects.Server()
drives = server.get_physical_drives()
if any((drive.erase_status == 'Erase In Progress') for drive in drives):
return False
else:
return True
def test___init__physical_disk_size_mb(self, get_all_details_mock):
ret = raid_constants.HPSSA_SMALL_SIZE_PHYSICAL_DRIVE
get_all_details_mock.return_value = ret
server = objects.Server()
self.assertEqual(
2, server.controllers[0].unassigned_physical_drives[0].size_gb)
def test_create_logical_drive_raid_level_mapping(self, execute_mock,
get_all_details_mock):
get_all_details_mock.return_value = raid_constants.HPSSA_NO_DRIVES
server = objects.Server()
controller = server.controllers[0]
logical_drive_info = {'size_gb': 50,
'raid_level': '5+0',
'volume_name': 'boot_volume',
'is_boot_volume': 'true',
'controller': 'Smart Array P822 in Slot 2',
'physical_disks': ['5I:1:1',
'5I:1:2',
'5I:1:3',
'5I:1:4',
'5I:1:5',
'6I:1:6']}
controller.create_logical_drive(logical_drive_info)
execute_mock.assert_called_once_with(
"create", "type=logicaldrive",
"drives=5I:1:1,5I:1:2,5I:1:3,5I:1:4,5I:1:5,6I:1:6",
"raid=50", "size=51200", process_input='y')
def test___init__physical_disk_ssd(self, get_all_details_mock):
get_all_details_mock.return_value = raid_constants.HPSSA_DRIVES_SSD
server = objects.Server()
d = [x for x in server.controllers[0].unassigned_physical_drives]
drives = sorted((x for x in d),
key=lambda x: x.get_physical_drive_dict()['id'])
ret_sas = drives[0].get_physical_drive_dict()
ret_sata = drives[1].get_physical_drive_dict()
self.assertEqual(200, ret_sas['size_gb'])
self.assertEqual('Smart Array P822 in Slot 2',
ret_sas['controller'])
self.assertEqual('6I:1:7', ret_sas['id'])
self.assertEqual('ssd', ret_sas['disk_type'])
self.assertEqual('sas', ret_sas['interface_type'])
self.assertEqual('HP EF0600FARNA', ret_sas['model'])
self.assertEqual('HPD6', ret_sas['firmware'])
self.assertEqual('ready', ret_sas['status'])
self.assertEqual('6I:1:8', ret_sata['id'])
self.assertEqual('ssd', ret_sata['disk_type'])
self.assertEqual('sata', ret_sata['interface_type'])
self.assertEqual('OK', ret_sata['erase_status'])
def test_allocate_disks_share_physical_disks_criteria_mismatch(
self, get_all_details_mock):
# Both the drives don't have firmware HPD6
get_all_details_mock.return_value = raid_constants.ONE_DRIVE_RAID_1
rdh = {'wwn': '0x600508b1001c02bd'}
controller = 'Smart Array P822 in Slot 2'
physical_disks = ['5I:1:1', '5I:1:2']
raid_config = {
'logical_disks': [{
'size_gb': 50,
'raid_level': '1',
'share_physical_disks': True,
'root_device_hint': rdh,
'controller': controller,
'physical_disks': physical_disks
}, {
'size_gb': 50,
'raid_level': '1',
'firmware': 'HPD6',
'share_physical_disks': True
}]
}
logical_disk = raid_config['logical_disks'][1]
server = objects.Server()
self.assertRaises(exception.PhysicalDisksNotFoundError,
disk_allocator.allocate_disks, logical_disk, server,
raid_config)
def test_allocate_disks_share_physical_disks_no_space(
self, execute_mock, get_all_details_mock):
get_all_details_mock.return_value = raid_constants.ONE_DRIVE_RAID_1
execute_mock.return_value = (
raid_constants.DRIVE_2_RAID_1_OKAY_TO_SHARE, None)
rdh = {'wwn': '0x600508b1001c02bd'}
controller = 'Smart Array P822 in Slot 2'
physical_disks = ['5I:1:1', '5I:1:2']
raid_config = {
'logical_disks': [{
'size_gb': 50,
'raid_level': '1',
'share_physical_disks': True,
'root_device_hint': rdh,
'controller': controller,
'physical_disks': physical_disks
}, {
'size_gb': 600,
'raid_level': '1',
'share_physical_disks': True
}]
}
logical_disk = raid_config['logical_disks'][1]
server = objects.Server()
self.assertRaises(exception.PhysicalDisksNotFoundError,
disk_allocator.allocate_disks, logical_disk, server,
raid_config)
def test_allocate_disks_share_physical_disks(self, execute_mock,
get_all_details_mock):
get_all_details_mock.return_value = raid_constants.ONE_DRIVE_RAID_1
execute_mock.return_value = (
raid_constants.DRIVE_2_RAID_1_OKAY_TO_SHARE, None)
rdh = {'wwn': '0x600508b1001c02bd'}
controller = 'Smart Array P822 in Slot 2'
physical_disks = ['5I:1:1', '5I:1:2']
raid_config = {
'logical_disks': [{
'size_gb': 50,
'raid_level': '1',
'share_physical_disks': True,
'root_device_hint': rdh,
'controller': controller,
'physical_disks': physical_disks
}, {
'size_gb': 50,
'raid_level': '1',
'share_physical_disks': True
}]
}
logical_disk = raid_config['logical_disks'][1]
server = objects.Server()
disk_allocator.allocate_disks(logical_disk, server, raid_config)
self.assertEqual(controller, logical_disk['controller'])
self.assertEqual('A', logical_disk['array'])
self.assertNotIn('physical_disks', logical_disk)
def test_allocate_disks_max_okay(self, get_all_details_mock):
get_all_details_mock.return_value = raid_constants.HPSSA_ONE_DRIVE
server = objects.Server()
logical_disk = {
'size_gb': 'MAX',
'raid_level': '1',
'disk_type': 'hdd',
'interface_type': 'sas'
}
# Decrease size of three disks so that the remaining gets
# selected.
disk1 = server.controllers[0].get_physical_drive_by_id('5I:1:3')
disk2 = server.controllers[0].get_physical_drive_by_id('6I:1:7')
disk3 = server.controllers[0].get_physical_drive_by_id('5I:1:4')
disk1.size_gb = 300
disk2.size_gb = 300
disk3.size_gb = 300
raid_config = {'logical_disks': [logical_disk]}
disk_allocator.allocate_disks(logical_disk, server, raid_config)
self.assertEqual('Smart Array P822 in Slot 2',
logical_disk['controller'])
self.assertEqual(sorted(['6I:1:5', '6I:1:6']),
sorted(logical_disk['physical_disks']))
def test_get_logical_drives(self, get_all_details_mock):
get_all_details_mock.return_value = raid_constants.HPSSA_ONE_DRIVE
server = objects.Server()
exp_ld = server.controllers[0].raid_arrays[0].logical_drives[0]
self.assertEqual(exp_ld, server.get_logical_drives()[0])
def test_get_logical_drives_no_drives(self, get_all_details_mock):
fobj = open('proliantutils/tests/hpssa/outputs/no_drives.out', 'r')
stdout = '\n'.join(fobj.readlines())
get_all_details_mock.return_value = stdout
server = objects.Server()
self.assertFalse(server.get_logical_drives())
def test_erase_devices(self, execute_mock, get_all_details_mock):
get_all_details_mock.return_value = raid_constants.SSA_ERASE_DRIVE
server = objects.Server()
d = [x for x in server.controllers[0].unassigned_physical_drives]
controller = server.controllers[0]
controller.erase_devices(d)
execute_mock.assert_called_once_with('pd 1I:2:1', 'modify', 'erase',
'erasepattern=overwrite',
'unrestricted=off', 'forced')
def test_server_object_one_logical_drive_raid_level_mappping(
self, get_all_details_mock):
stdout = raid_constants.HPSSA_ONE_DRIVE_RAID_50
get_all_details_mock.return_value = stdout
server = objects.Server()
logical_drive = server.controllers[0].raid_arrays[0].logical_drives[0]
self.assertEqual(constants.RAID_50, logical_drive.raid_level)
def test_can_accomodate_oserror(self, execute_mock, get_all_details_mock):
current_config = raid_constants.HPSSA_TWO_DRIVES_100GB_RAID5_50GB_RAID1
get_all_details_mock.return_value = current_config
execute_mock.side_effect = OSError
logical_disk = {'size_gb': 1500, 'raid_level': '1'}
server = objects.Server()
self.assertRaises(exception.HPSSAOperationError,
server.controllers[0].raid_arrays[0].can_accomodate,
logical_disk)
def test_get_logical_drive_by_wwn_not_exist(self, get_all_details_mock):
two_drives = raid_constants.HPSSA_TWO_DRIVES_100GB_RAID5_50GB_RAID1
get_all_details_mock.return_value = two_drives
server = objects.Server()
wwn = 'foo'
ld_ret = server.get_logical_drive_by_wwn(wwn)
self.assertIsNone(ld_ret)
def test_can_accomodate_okay(self, execute_mock, get_all_details_mock):
current_config = raid_constants.HPSSA_TWO_DRIVES_100GB_RAID5_50GB_RAID1
get_all_details_mock.return_value = current_config
execute_mock.return_value = (
raid_constants.ARRAY_ACCOMODATE_LOGICAL_DISK, None)
logical_disk = {'size_gb': 500, 'raid_level': '5'}
server = objects.Server()
ret_val = server.controllers[0].raid_arrays[0].can_accomodate(
logical_disk)
self.assertTrue(ret_val)
def test_get_logical_drives(self, get_all_details_mock):
fobj = open('proliantutils/tests/hpssa/outputs/one_drive.out', 'r')
stdout = '\n'.join(fobj.readlines())
get_all_details_mock.return_value = stdout
server = objects.Server()
exp_ld = server.controllers[0].raid_arrays[0].logical_drives[0]
self.assertEqual(exp_ld, server.get_logical_drives()[0])
def test_get_controller_by_id(self, get_all_details_mock):
get_all_details_mock.return_value = raid_constants.HPSSA_ONE_DRIVE
server = objects.Server()
id = 'Smart Array P822 in Slot 2'
self.assertEqual(server.controllers[0],
server.get_controller_by_id(id))
self.assertIsNone(server.get_controller_by_id('foo'))
def test_execute_cmd_fails(self, processutils_mock, get_all_details_mock):
get_all_details_mock.return_value = raid_constants.HPSSA_NO_DRIVES
server = objects.Server()
controller = server.controllers[0]
processutils_mock.side_effect = OSError
self.assertRaises(exception.HPSSAOperationError,
controller.execute_cmd, 'foo', 'bar')
def test_can_accomodate_map_raid_level(self, execute_mock,
get_all_details_mock):
current_config = raid_constants.HPSSA_TWO_DRIVES_100GB_RAID5_50GB_RAID1
execute_mock.return_value = ("", None)
get_all_details_mock.return_value = current_config
logical_disk = {'size_gb': 1500, 'raid_level': '5+0'}
server = objects.Server()
server.controllers[0].raid_arrays[0].can_accomodate(logical_disk)
execute_mock.assert_called_once_with(
"hpssacli", "controller", "slot=2", "array", mock.ANY, "create",
"type=logicaldrive", "raid=50", "size=?")
def test__select_controllers_by(self, get_all_details_mock):
get_all_details_mock.return_value = raid_constants.HPSSA_NO_DRIVES
server = objects.Server()
select_controllers = lambda x: not x.properties.get('HBA Mode Enabled',
False)
ctrl_expected = server.controllers
manager._select_controllers_by(server, select_controllers,
'Raid enabled')
self.assertEqual(ctrl_expected, server.controllers)
def test_delete_all_logical_drives(self, execute_mock,
get_all_details_mock):
get_all_details_mock.return_value = raid_constants.HPSSA_NO_DRIVES
server = objects.Server()
controller = server.controllers[0]
controller.delete_all_logical_drives()
execute_mock.assert_called_once_with("logicaldrive", "all",
"delete", "forced")
def test_get_controller_by_id(self, get_all_details_mock):
fobj = open('proliantutils/tests/hpssa/outputs/one_drive.out', 'r')
stdout = '\n'.join(fobj.readlines())
get_all_details_mock.return_value = stdout
server = objects.Server()
id = 'Smart Array P822 in Slot 2'
self.assertEqual(server.controllers[0],
server.get_controller_by_id(id))
self.assertIsNone(server.get_controller_by_id('foo'))
def test_get_logical_drive_by_wwn(self, get_all_details_mock):
two_drives = raid_constants.HPSSA_TWO_DRIVES_100GB_RAID5_50GB_RAID1
get_all_details_mock.return_value = two_drives
server = objects.Server()
wwn = '0x600508b1001cc42c'
ld_ret = server.get_logical_drive_by_wwn(wwn)
raid_arrays = server.controllers[0].raid_arrays
ld_exp = [x.logical_drives[0] for x in raid_arrays
if x.logical_drives[0].raid_level == '5'][0]
self.assertEqual(ld_exp, ld_ret)
def test_execute_cmd_fails(self, processutils_mock, get_all_details_mock):
fobj = open('proliantutils/tests/hpssa/outputs/no_drives.out', 'r')
stdout = '\n'.join(fobj.readlines())
get_all_details_mock.return_value = stdout
server = objects.Server()
controller = server.controllers[0]
processutils_mock.side_effect = OSError
self.assertRaises(exception.HPSSAOperationError,
controller.execute_cmd, 'foo', 'bar')
def test_get_physical_drives(self, get_all_details_mock):
get_all_details_mock.return_value = raid_constants.HPSSA_ONE_DRIVE
server = objects.Server()
exp_pds = [server.controllers[0].unassigned_physical_drives[0],
server.controllers[0].unassigned_physical_drives[1],
server.controllers[0].unassigned_physical_drives[2],
server.controllers[0].unassigned_physical_drives[3],
server.controllers[0].unassigned_physical_drives[4],
server.controllers[0].raid_arrays[0].physical_drives[0],
server.controllers[0].raid_arrays[0].physical_drives[1]]
self.assertEqual(exp_pds, server.get_physical_drives())
def test_delete_all_logical_drives(self, execute_mock,
get_all_details_mock):
fobj = open('proliantutils/tests/hpssa/outputs/no_drives.out', 'r')
stdout = '\n'.join(fobj.readlines())
get_all_details_mock.return_value = stdout
server = objects.Server()
controller = server.controllers[0]
controller.delete_all_logical_drives()
execute_mock.assert_called_once_with("logicaldrive", "all", "delete",
"forced")
def test_get_logical_drive_dict(self, get_all_details_mock):
get_all_details_mock.return_value = raid_constants.HPSSA_ONE_DRIVE
server = objects.Server()
logical_drive = server.controllers[0].raid_arrays[0].logical_drives[0]
ret = logical_drive.get_logical_drive_dict()
self.assertEqual(557, ret['size_gb'])
self.assertEqual('1', ret['raid_level'])
self.assertEqual('0x600508b1001c321c', ret['root_device_hint']['wwn'])
self.assertEqual('Smart Array P822 in Slot 2', ret['controller'])
self.assertEqual(sorted(['5I:1:1', '5I:1:2']),
sorted(ret['physical_disks']))
self.assertEqual('01F42227PDVTF0BRH5T0MOAB64', ret['volume_name'])
