def test_with_candidates(self): obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), power_state='power on', resource_class='x-large', provision_state='available') node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), power_state='power on', resource_class='x-large', provision_state='available') allocation = obj_utils.create_test_allocation( self.context, resource_class='x-large', candidate_nodes=[node['uuid']]) allocations.do_allocate(self.context, allocation) allocation = objects.Allocation.get_by_uuid(self.context, allocation['uuid']) self.assertIsNone(allocation['last_error']) self.assertEqual('active', allocation['state']) node = objects.Node.get_by_uuid(self.context, node['uuid']) self.assertEqual(allocation['uuid'], node['instance_uuid']) self.assertEqual(allocation['id'], node['allocation_id']) self.assertEqual([node['uuid']], allocation['candidate_nodes'])
def test_nodes_locked(self, mock_acquire): self.config(node_locked_retry_attempts=2, group='conductor') node1 = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), maintenance=False, resource_class='x-large', power_state='power off', provision_state='available', reservation='example.com') node2 = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), resource_class='x-large', power_state='power off', provision_state='available', reservation='example.com') allocation = obj_utils.create_test_allocation(self.context, resource_class='x-large') allocations.do_allocate(self.context, allocation) self.assertIn('could not reserve any of 2', allocation['last_error']) self.assertEqual('error', allocation['state']) self.assertEqual(6, mock_acquire.call_count) # NOTE(dtantsur): node are tried in random order by design, so we # cannot directly use assert_has_calls. Check that all nodes are tried # before going into retries (rather than each tried 3 times in a row). nodes = [call[0][1] for call in mock_acquire.call_args_list] for offset in (0, 2, 4): self.assertEqual(set(nodes[offset:offset + 2]), {node1.uuid, node2.uuid})
def test__start_consoles_no_console_enabled(self, mock_notify, mock_start_console): obj_utils.create_test_node(self.context, driver='fake-hardware', console_enabled=False) self._start_service() self.service._start_consoles(self.context) self.assertFalse(mock_start_console.called) self.assertFalse(mock_notify.called)
def test__start_consoles_no_console_enabled(self): obj_utils.create_test_node(self.context, driver='fake', console_enabled=False) self._start_service() with mock.patch.object(self.driver.console, 'start_console') as mock_start_console: self.service._start_consoles(self.context) self.assertFalse(mock_start_console.called)
def setUp(self): super(TestLookup, self).setUp() self.node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), provision_state='deploying') self.node2 = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), provision_state='available') CONF.set_override('agent_backend', 'statsd', 'metrics')
def test_delete_chassis_with_node(self): chassis = obj_utils.create_test_chassis(self.context) obj_utils.create_test_node(self.context, chassis_id=chassis.id) response = self.delete('/chassis/%s' % chassis.uuid, expect_errors=True) self.assertEqual(http_client.BAD_REQUEST, response.status_int) self.assertEqual('application/json', response.content_type) self.assertTrue(response.json['error_message']) self.assertIn(chassis.uuid, response.json['error_message'])
def test_create_allocation_with_candidate_nodes(self): node1 = obj_utils.create_test_node(self.context, name='node-1') node2 = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid()) adict = apiutils.allocation_post_data( candidate_nodes=[node1.name, node2.uuid]) response = self.post_json('/allocations', adict, headers=self.headers) self.assertEqual(http_client.CREATED, response.status_int) result = self.get_json('/allocations/%s' % adict['uuid'], headers=self.headers) self.assertEqual(adict['uuid'], result['uuid']) self.assertEqual([node1.uuid, node2.uuid], result['candidate_nodes'])
def test_delete_chassis_with_node(self, mock_notify): chassis = obj_utils.create_test_chassis(self.context) obj_utils.create_test_node(self.context, chassis_id=chassis.id) response = self.delete('/chassis/%s' % chassis.uuid, expect_errors=True) self.assertEqual(http_client.BAD_REQUEST, response.status_int) self.assertEqual('application/json', response.content_type) self.assertTrue(response.json['error_message']) self.assertIn(chassis.uuid, response.json['error_message']) mock_notify.assert_has_calls([mock.call(mock.ANY, mock.ANY, 'delete', obj_fields.NotificationLevel.INFO, obj_fields.NotificationStatus.START), mock.call(mock.ANY, mock.ANY, 'delete', obj_fields.NotificationLevel.ERROR, obj_fields.NotificationStatus.ERROR)])
def test_start_clears_conductor_locks(self): node = obj_utils.create_test_node(self.context, reservation=self.hostname) node.save() self._start_service() node.refresh() self.assertIsNone(node.reservation)
def setUp(self): super(iPXEValidateRescueTestCase, self).setUp() for iface in drivers_base.ALL_INTERFACES: impl = 'fake' if iface == 'network': impl = 'flat' if iface == 'rescue': impl = 'agent' if iface == 'boot': impl = 'ipxe' config_kwarg = {'enabled_%s_interfaces' % iface: [impl], 'default_%s_interface' % iface: impl} self.config(**config_kwarg) self.config(enabled_hardware_types=['fake-hardware']) driver_info = DRV_INFO_DICT driver_info.update({'rescue_ramdisk': 'my_ramdisk', 'rescue_kernel': 'my_kernel'}) instance_info = INST_INFO_DICT instance_info.update({'rescue_password': '******'}) n = { 'driver': 'fake-hardware', 'instance_info': instance_info, 'driver_info': driver_info, 'driver_internal_info': DRV_INTERNAL_INFO_DICT, } self.node = obj_utils.create_test_node(self.context, **n)
def setUp(self): super(DracPeriodicTaskTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake_drac') self.node = obj_utils.create_test_node(self.context, driver='fake_drac', driver_info=INFO_DICT) self.driver = driver_factory.get_driver("fake_drac") self.job = { 'id': 'JID_001436912645', 'name': 'ConfigBIOS:BIOS.Setup.1-1', 'start_time': '00000101000000', 'until_time': 'TIME_NA', 'message': 'Job in progress', 'state': 'Running', 'percent_complete': 34} self.virtual_disk = { 'id': 'Disk.Virtual.0:RAID.Integrated.1-1', 'name': 'disk 0', 'description': 'Virtual Disk 0 on Integrated RAID Controller 1', 'controller': 'RAID.Integrated.1-1', 'raid_level': '1', 'size_mb': 571776, 'state': 'ok', 'raid_state': 'online', 'span_depth': 1, 'span_length': 2, 'pending_operations': None }
def setUp(self): super(TaskManagerTestCase, self).setUp() self.host = 'test-host' self.config(host=self.host) self.config(node_locked_retry_attempts=1, group='conductor') self.config(node_locked_retry_interval=0, group='conductor') self.node = obj_utils.create_test_node(self.context)
def setUp(self): super(AMTManagementTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake_amt_fake') self.info = INFO_DICT self.node = obj_utils.create_test_node(self.context, driver='fake_amt_fake', driver_info=self.info)
def _test_update_raid_info(self, current_config, capabilities=None): node = obj_utils.create_test_node(self.context, driver="fake") if capabilities: properties = node.properties properties["capabilities"] = capabilities del properties["local_gb"] node.properties = properties target_raid_config = json.loads(raid_constants.RAID_CONFIG_OKAY) node.target_raid_config = target_raid_config node.save() raid.update_raid_info(node, current_config) properties = node.properties current = node.raid_config target = node.target_raid_config self.assertIsNotNone(current["last_updated"]) self.assertIsInstance(current["logical_disks"][0], dict) if current_config["logical_disks"][0].get("is_root_volume"): self.assertEqual({"wwn": "600508B100"}, properties["root_device"]) self.assertEqual(100, properties["local_gb"]) self.assertIn("raid_level:1", properties["capabilities"]) if capabilities: self.assertIn(capabilities, properties["capabilities"]) else: self.assertNotIn("local_gb", properties) self.assertNotIn("root_device", properties) if capabilities: self.assertNotIn("raid_level:1", properties["capabilities"]) # Verify node.target_raid_config is preserved. self.assertEqual(target_raid_config, target)
def test_node_power_action_set_power_failure(self): """Test if an exception is thrown when the set_power call fails.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), driver='fake', power_state=states.POWER_OFF) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') as get_power_mock: with mock.patch.object(self.driver.power, 'set_power_state') as set_power_mock: get_power_mock.return_value = states.POWER_OFF set_power_mock.side_effect = exception.IronicException() self.assertRaises( exception.IronicException, conductor_utils.node_power_action, task, states.POWER_ON) node.refresh() get_power_mock.assert_called_once_with(mock.ANY) set_power_mock.assert_called_once_with(mock.ANY, states.POWER_ON) self.assertEqual(states.POWER_OFF, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNotNone(node['last_error'])
def test__validate_user_clean_steps_no_steps(self, mock_steps): node = obj_utils.create_test_node(self.context) mock_steps.return_value = self.clean_steps with task_manager.acquire(self.context, node.uuid) as task: conductor_utils._validate_user_clean_steps(task, []) mock_steps.assert_called_once_with(task, enabled=False, sort=False)
def test_node_power_action_in_same_state(self): """Test setting node state to its present state. Test that we don't try to set the power state if the requested state is the same as the current state. """ node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), driver='fake', last_error='anything but None', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') as get_power_mock: get_power_mock.return_value = states.POWER_ON with mock.patch.object(self.driver.power, 'set_power_state') as set_power_mock: conductor_utils.node_power_action(task, states.POWER_ON) node.refresh() get_power_mock.assert_called_once_with(mock.ANY) self.assertFalse(set_power_mock.called, "set_power_state unexpectedly called") self.assertEqual(states.POWER_ON, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNone(node['last_error'])
def test_node_power_action_in_same_state_db_not_in_sync(self): """Test setting node state to its present state if DB is out of sync. Under rare conditions (see bug #1403106) database might contain stale information, make sure we fix it. """ node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), driver='fake', last_error='anything but None', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') as get_power_mock: get_power_mock.return_value = states.POWER_OFF with mock.patch.object(self.driver.power, 'set_power_state') as set_power_mock: conductor_utils.node_power_action(task, states.POWER_OFF) node.refresh() get_power_mock.assert_called_once_with(mock.ANY) self.assertFalse(set_power_mock.called, "set_power_state unexpectedly called") self.assertEqual(states.POWER_OFF, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNone(node['last_error'])
def test_parse_driver_info_missing_username(self): node = obj_utils.create_test_node(self.context, driver='fake_drac', driver_info=INFO_DICT) del node.driver_info['drac_username'] self.assertRaises(exception.InvalidParameterValue, drac_common.parse_driver_info, node)
def test_node_power_action_invalid_state(self): """Test for exception when changing to an invalid power state.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), driver='fake', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') as get_power_mock: get_power_mock.return_value = states.POWER_ON self.assertRaises(exception.InvalidParameterValue, conductor_utils.node_power_action, task, "INVALID_POWER_STATE") node.refresh() get_power_mock.assert_called_once_with(mock.ANY) self.assertEqual(states.POWER_ON, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNotNone(node['last_error']) # last_error is cleared when a new transaction happens conductor_utils.node_power_action(task, states.POWER_OFF) node.refresh() self.assertEqual(states.POWER_OFF, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNone(node['last_error'])
def setUp(self): super(TestNeutron, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake') self.config( cleaning_network='00000000-0000-0000-0000-000000000000', group='neutron') self.config(enabled_drivers=['fake']) self.config(dhcp_provider='neutron', group='dhcp') self.config(url='test-url', url_timeout=30, retries=2, group='neutron') self.config(insecure=False, certfile='test-file', admin_user='******', admin_tenant_name='test-admin-tenant', admin_password='******', auth_uri='test-auth-uri', group='keystone_authtoken') self.node = object_utils.create_test_node(self.context) self.ports = [ object_utils.create_test_port( self.context, node_id=self.node.id, id=2, uuid='1be26c0b-03f2-4d2e-ae87-c02d7f33c782', address='52:54:00:cf:2d:32')] # Very simple neutron port representation self.neutron_port = {'id': '132f871f-eaec-4fed-9475-0d54465e0f00', 'mac_address': '52:54:00:cf:2d:32'} dhcp_factory.DHCPFactory._dhcp_provider = None
def test_parse_driver_info_invalid_port(self): node = obj_utils.create_test_node(self.context, driver='fake_drac', driver_info=INFO_DICT) node.driver_info['drac_port'] = 'foo' self.assertRaises(exception.InvalidParameterValue, drac_common.parse_driver_info, node)
def test_portgroup_by_id_no_such_portgroup(self): node = object_utils.create_test_node(self.context) object_utils.create_test_portgroup(self.context, node_id=node.id) with task_manager.acquire(self.context, node.uuid) as task: portgroup_id = 'invalid-portgroup-id' res = network.get_portgroup_by_id(task, portgroup_id) self.assertIsNone(res)
def setUp(self): super(AwakeAMTInterfaceTestCase, self).setUp() amt_common.AMT_AWAKE_CACHE = {} self.info = INFO_DICT self.node = obj_utils.create_test_node(self.context, driver='fake_amt', driver_info=self.info)
def test_ports_by_portgroup_id_empty(self): node = object_utils.create_test_node(self.context) portgroup = object_utils.create_test_portgroup(self.context, node_id=node.id) with task_manager.acquire(self.context, node.uuid) as task: res = network.get_ports_by_portgroup_id(task, portgroup.id) self.assertEqual([], res)
def test_nodes_subresource(self): chassis = obj_utils.create_test_chassis(self.context) for id_ in range(2): obj_utils.create_test_node(self.context, chassis_id=chassis.id, uuid=uuidutils.generate_uuid()) data = self.get_json('/chassis/%s/nodes' % chassis.uuid) self.assertEqual(2, len(data['nodes'])) self.assertNotIn('next', data) # Test collection pagination data = self.get_json('/chassis/%s/nodes?limit=1' % chassis.uuid) self.assertEqual(1, len(data['nodes'])) self.assertIn('next', data)
def test_build_driver_for_task_calculated_defaults(self): self.config(dhcp_provider=None, group="dhcp") node = obj_utils.create_test_node(self.context, driver="fake-hardware") with task_manager.acquire(self.context, node.id) as task: for iface in drivers_base.ALL_INTERFACES: impl = getattr(task.driver, iface) self.assertIsNotNone(impl)
def setUp(self): irmc_boot.check_share_fs_mounted_patcher.start() self.addCleanup(irmc_boot.check_share_fs_mounted_patcher.stop) super(IRMCVirtualMediaBootTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="iscsi_irmc") self.node = obj_utils.create_test_node( self.context, driver='iscsi_irmc', driver_info=INFO_DICT)
def test__add_image_deployment_config_not_alphanum_name(self): origin_image = { 'name': 'dashes-in-name', 'url': 'name1', 'target': '/' } provision_conf = {'images': [origin_image.copy()]} node = test_utils.create_test_node( self.context, driver_info={}, instance_info={'image_source': 'uuid1'}) with task_manager.acquire(self.context, node.uuid, driver_name='bare_swift_ssh') as task: task.node = node deploy = bareon_base.BareonDeploy() with mock.patch.object( bareon_base, 'get_tenant_images_json_path') as path: tenant_images_path = self.temp_dir.join('tenant_images.json') path.side_effect = lambda node: tenant_images_path result = deploy._add_image_deployment_config( task, provision_conf) result_image = result['images'] result_image = result_image[0] self.assertEqual(origin_image['name'], result_image['name'])
def setUp(self): super(IloPowerTestCase, self).setUp() driver_info = INFO_DICT mgr_utils.mock_the_extension_manager(driver="fake_ilo") self.node = obj_utils.create_test_node(self.context, driver='fake_ilo', driver_info=driver_info)
def setUp(self): super(IloBootPrivateMethodsTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="iscsi_ilo") self.node = obj_utils.create_test_node( self.context, driver='iscsi_ilo', driver_info=INFO_DICT)
def setUp(self): super(VendorPassthruTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="iscsi_ilo") self.node = obj_utils.create_test_node(self.context, driver='iscsi_ilo', driver_info=INFO_DICT)
def setUp(self): super(TestCinderActions, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake') self.config(enabled_drivers=['fake']) self.node = object_utils.create_test_node( self.context, instance_uuid=uuidutils.generate_uuid())
def test_build_driver_for_task_bad_default(self): self.config(default_power_interface='foobar') node = obj_utils.create_test_node(self.context, driver='fake-hardware') self.assertRaises(exception.InterfaceNotFoundInEntrypoint, task_manager.acquire, self.context, node.id)
def setUp(self): super(IPMINativePrivateMethodTestCase, self).setUp() self.node = obj_utils.create_test_node(self.context, driver='fake_ipminative', driver_info=INFO_DICT) self.info = ipminative._parse_driver_info(self.node)
def setUp(self): super(DracJobTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake_drac') self.node = obj_utils.create_test_node(self.context, driver='fake_drac', driver_info=INFO_DICT)
def test_override_no_vendor(self): node = obj_utils.create_test_node(self.context, driver='idrac', vendor_interface='no-vendor') with task_manager.acquire(self.context, node.id) as task: self._validate_interfaces(task.driver, vendor=noop.NoVendor)
def setUp(self): super(UtilsTestCase, self).setUp() mgr_utils.mock_the_extension_manager() self.driver = driver_factory.get_driver("fake") self.node = obj_utils.create_test_node(self.context)
def setUp(self): super(UtilsTestCase, self).setUp() self.node = obj_utils.create_test_node(self.context)
def setUp(self): super(IloValidateParametersTestCase, self).setUp() self.node = obj_utils.create_test_node(self.context, driver='fake_ilo', driver_info=INFO_DICT)
def setUp(self): super(IloManagementTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="fake_ilo") self.node = obj_utils.create_test_node(self.context, driver='fake_ilo', driver_info=INFO_DICT)
def setUp(self): super(InspectFunctionTestCase, self).setUp() self.node = obj_utils.create_test_node(self.context, boot_interface='pxe')
def setUp(self): super(TestPost, self).setUp() self.node = obj_utils.create_test_node(self.context)
def setUp(self): super(StoreConfigDriveTestCase, self).setUp() self.node = obj_utils.create_test_node(self.context, driver='fake-hardware', instance_info=None)
def test_override_with_raid(self): node = obj_utils.create_test_node(self.context, driver='idrac', raid_interface='no-raid') with task_manager.acquire(self.context, node.id) as task: self._validate_interfaces(task.driver, raid=noop.NoRAID)
def setUp(self): super(DracBootTestCase, self).setUp() self.node = obj_utils.create_test_node(self.context, driver='idrac', driver_info=INFO_DICT)
def test_default_interfaces(self): node = obj_utils.create_test_node(self.context, driver='cisco-ucs-standalone') with task_manager.acquire(self.context, node.id) as task: self._validate_interfaces(task)
def setUp(self): super(TestListVolumeConnectors, self).setUp() self.node = obj_utils.create_test_node(self.context)
def setUp(self): super(IloVirtualMediaAgentDeployTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="agent_ilo") self.node = obj_utils.create_test_node(self.context, driver='agent_ilo', driver_info=INFO_DICT)
def test_build_driver_for_task(self): node = obj_utils.create_test_node(self.context, driver='fake') with task_manager.acquire(self.context, node.id) as task: for iface in drivers_base.ALL_INTERFACES: impl = getattr(task.driver, iface) self.assertIsNotNone(impl)
def setUp(self): super(CleanUpFullFlowTestCase, self).setUp() self.config(image_cache_size=0, group='pxe') # Configure node mgr_utils.mock_the_extension_manager(driver="fake_pxe") instance_info = INST_INFO_DICT instance_info['deploy_key'] = 'fake-56789' self.node = obj_utils.create_test_node( self.context, driver='fake_pxe', instance_info=instance_info, driver_info=DRV_INFO_DICT, driver_internal_info=DRV_INTERNAL_INFO_DICT, ) self.port = obj_utils.create_test_port(self.context, node_id=self.node.id) # Configure temporary directories pxe_temp_dir = tempfile.mkdtemp() self.config(tftp_root=pxe_temp_dir, group='pxe') tftp_master_dir = os.path.join(CONF.pxe.tftp_root, 'tftp_master') self.config(tftp_master_path=tftp_master_dir, group='pxe') os.makedirs(tftp_master_dir) instance_temp_dir = tempfile.mkdtemp() self.config(images_path=instance_temp_dir, group='pxe') instance_master_dir = os.path.join(CONF.pxe.images_path, 'instance_master') self.config(instance_master_path=instance_master_dir, group='pxe') os.makedirs(instance_master_dir) self.pxe_config_dir = os.path.join(CONF.pxe.tftp_root, 'pxelinux.cfg') os.makedirs(self.pxe_config_dir) # Populate some file names self.master_kernel_path = os.path.join(CONF.pxe.tftp_master_path, 'kernel') self.master_instance_path = os.path.join(CONF.pxe.instance_master_path, 'image_uuid') self.node_tftp_dir = os.path.join(CONF.pxe.tftp_root, self.node.uuid) os.makedirs(self.node_tftp_dir) self.kernel_path = os.path.join(self.node_tftp_dir, 'kernel') self.node_image_dir = iscsi_deploy._get_image_dir_path(self.node.uuid) os.makedirs(self.node_image_dir) self.image_path = iscsi_deploy._get_image_file_path(self.node.uuid) self.config_path = pxe_utils.get_pxe_config_file_path(self.node.uuid) self.mac_path = pxe_utils._get_pxe_mac_path(self.port.address) # Create files self.files = [self.config_path, self.master_kernel_path, self.master_instance_path] for fname in self.files: # NOTE(dtantsur): files with 0 size won't be cleaned up with open(fname, 'w') as fp: fp.write('test') os.link(self.config_path, self.mac_path) os.link(self.master_kernel_path, self.kernel_path) os.link(self.master_instance_path, self.image_path) dhcp_factory.DHCPFactory._dhcp_provider = None
def setUp(self): super(TestPXEUtils, self).setUp() mgr_utils.mock_the_extension_manager(driver="fake") common_pxe_options = { 'deployment_aki_path': u'/tftpboot/1be26c0b-03f2-4d2e-ae87-' u'c02d7f33c123/deploy_kernel', 'aki_path': u'/tftpboot/1be26c0b-03f2-4d2e-ae87-c02d7f33c123/' u'kernel', 'ari_path': u'/tftpboot/1be26c0b-03f2-4d2e-ae87-c02d7f33c123/' u'ramdisk', 'pxe_append_params': 'test_param', 'deployment_ari_path': u'/tftpboot/1be26c0b-03f2-4d2e-ae87-c02d7' u'f33c123/deploy_ramdisk', 'root_device': 'vendor=fake,size=123', 'ipa-api-url': 'http://192.168.122.184:6385', 'ipxe_timeout': 0, } self.pxe_options = { 'deployment_key': '0123456789ABCDEFGHIJKLMNOPQRSTUV', 'iscsi_target_iqn': u'iqn-1be26c0b-03f2-4d2e-ae87-c02d7f33' u'c123', 'deployment_id': u'1be26c0b-03f2-4d2e-ae87-c02d7f33c123', 'ironic_api_url': 'http://192.168.122.184:6385', 'disk': 'cciss/c0d0,sda,hda,vda', 'boot_option': 'netboot', 'ipa-driver-name': 'pxe_ssh', } self.pxe_options.update(common_pxe_options) self.pxe_options_bios = { 'boot_mode': 'bios', } self.pxe_options_bios.update(self.pxe_options) self.pxe_options_uefi = { 'boot_mode': 'uefi', } self.pxe_options_uefi.update(self.pxe_options) self.agent_pxe_options = { 'ipa-driver-name': 'agent_ipmitool', } self.agent_pxe_options.update(common_pxe_options) self.ipxe_options = self.pxe_options.copy() self.ipxe_options.update({ 'deployment_aki_path': 'http://1.2.3.4:1234/deploy_kernel', 'deployment_ari_path': 'http://1.2.3.4:1234/deploy_ramdisk', 'aki_path': 'http://1.2.3.4:1234/kernel', 'ari_path': 'http://1.2.3.4:1234/ramdisk', }) self.ipxe_options_bios = { 'boot_mode': 'bios', } self.ipxe_options_bios.update(self.ipxe_options) self.ipxe_options_timeout = self.ipxe_options_bios.copy() self.ipxe_options_timeout.update({'ipxe_timeout': 120}) self.ipxe_options_uefi = { 'boot_mode': 'uefi', } self.ipxe_options_uefi.update(self.ipxe_options) self.node = object_utils.create_test_node(self.context)
def setUp(self): super(AMTManagementInteralMethodsTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake_amt') self.node = obj_utils.create_test_node(self.context, driver='fake_amt', driver_info=INFO_DICT)
def setUp(self): super(TestCinderActions, self).setUp() self.node = object_utils.create_test_node( self.context, instance_uuid=uuidutils.generate_uuid())
def test_override_with_inspector(self): node = obj_utils.create_test_node(self.context, driver='idrac', inspect_interface='inspector') with task_manager.acquire(self.context, node.id) as task: self._validate_interfaces(task.driver, inspect=inspector.Inspector)
def setUp(self): super(IloCommonMethodsTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="fake_ilo") self.info = db_utils.get_test_ilo_info() self.node = obj_utils.create_test_node( self.context, driver='fake_ilo', driver_info=self.info)
def setUp(self): super(IRMCValidateParametersTestCase, self).setUp() self.node = obj_utils.create_test_node( self.context, driver='fake_irmc', driver_info=db_utils.get_test_irmc_info())
def test_build_driver_for_task_unknown_network_interface(self): node = obj_utils.create_test_node(self.context, driver='fake', network_interface='meow') self.assertRaises(exception.InterfaceNotFoundInEntrypoint, task_manager.acquire, self.context, node.id)
def setUp(self): super(AMTISCSIDeployTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="pxe_amt_iscsi") self.node = obj_utils.create_test_node(self.context, driver='pxe_amt_iscsi', driver_info=INFO_DICT)
def setUp(self): super(TestPost, self).setUp() self.node = obj_utils.create_test_node(self.context) self.headers = { api_base.Version.string: str(versions.MAX_VERSION_STRING) }