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'])