def setUp(self): super(LibvirtManagementTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="fake_libvirt_fake") driver_factory.get_driver("fake_libvirt_fake") self.node = obj_utils.create_test_node( self.context, driver='fake_libvirt_fake', driver_info=_get_test_libvirt_driver_info('sasl')) obj_utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:5c:b7:df')
def __init__(self, context, node_id, shared=False, driver_name=None): """Create a new TaskManager. Acquire a lock on a node. The lock can be either shared or exclusive. Shared locks may be used for read-only or non-disruptive actions only, and must be considerate to what other threads may be doing on the same node at the same time. :param context: request context :param node_id: ID or UUID of node to lock. :param shared: Boolean indicating whether to take a shared or exclusive lock. Default: False. :param driver_name: The name of the driver to load, if different from the Node's current driver. :raises: DriverNotFound :raises: NodeNotFound :raises: NodeLocked """ self._spawn_method = None self._on_error_method = None self.context = context self.node = None self.shared = shared self.fsm = states.machine.copy() # NodeLocked exceptions can be annoying. Let's try to alleviate # some of that pain by retrying our lock attempts. The retrying # module expects a wait_fixed value in milliseconds. @retrying.retry( retry_on_exception=lambda e: isinstance(e, exception.NodeLocked), stop_max_attempt_number=CONF.conductor.node_locked_retry_attempts, wait_fixed=CONF.conductor.node_locked_retry_interval * 1000, ) def reserve_node(): LOG.debug("Attempting to reserve node %(node)s", {"node": node_id}) self.node = objects.Node.reserve(context, CONF.host, node_id) try: if not self.shared: reserve_node() else: self.node = objects.Node.get(context, node_id) self.ports = objects.Port.list_by_node_id(context, self.node.id) self.driver = driver_factory.get_driver(driver_name or self.node.driver) # NOTE(deva): this handles the Juno-era NOSTATE state # and should be deleted after Kilo is released if self.node.provision_state is states.NOSTATE: self.node.provision_state = states.AVAILABLE self.node.save() self.fsm.initialize(self.node.provision_state) except Exception: with excutils.save_and_reraise_exception(): self.release_resources()
def setUp(self): super(SSHDriverTestCase, self).setUp() self.context = context.get_admin_context() mgr_utils.mock_the_extension_manager(driver="fake_ssh") self.driver = driver_factory.get_driver("fake_ssh") n = db_utils.get_test_node( driver='fake_ssh', driver_info=INFO_DICT) self.dbapi = dbapi.get_instance() self.node = self.dbapi.create_node(n) self.port = self.dbapi.create_port(db_utils.get_test_port( node_id=self.node.id)) self.sshclient = paramiko.SSHClient() #setup these mocks because most tests use them self.parse_drv_info_patcher = mock.patch.object(ssh, '_parse_driver_info') self.parse_drv_info_mock = None self.get_mac_addr_patcher = mock.patch.object( ssh, '_get_nodes_mac_addresses') self.get_mac_addr_mock = self.get_mac_addr_patcher.start() self.get_conn_patcher = mock.patch.object(ssh, '_get_connection') self.get_conn_mock = self.get_conn_patcher.start() def stop_patchers(): if self.parse_drv_info_mock: self.parse_drv_info_patcher.stop() if self.get_mac_addr_mock: self.get_mac_addr_patcher.stop() if self.get_conn_mock: self.get_conn_patcher.stop() self.addCleanup(stop_patchers)
def setUp(self): super(OneViewManagementDriverTestCase, self).setUp() self.config(manager_url="https://1.2.3.4", group="oneview") self.config(username="******", group="oneview") self.config(password="******", group="oneview") self.mock_verify_oneview_version_obj = mock.patch.object( oneview_client, "verify_oneview_version", autospec=True, return_value=120 ) self.mock_verify_oneview_version = self.mock_verify_oneview_version_obj.start() self.addCleanup(self.mock_verify_oneview_version_obj.stop) self.mock_check_oneview_status_obj = mock.patch.object( oneview_client, "check_oneview_status", autospec=True, return_value=200 ) self.mock_check_oneview_status = self.mock_check_oneview_status_obj.start() self.addCleanup(self.mock_check_oneview_status_obj.stop) mgr_utils.mock_the_extension_manager(driver="fake_oneview") self.driver = driver_factory.get_driver("fake_oneview") self.node = obj_utils.create_test_node( self.context, driver="fake_oneview", properties=PROPERTIES_DICT, extra=EXTRA_DICT, driver_info=DRIVER_INFO_DICT, instance_info=INSTANCE_INFO_DICT, ) self.info = common.parse_driver_info(self.node)
def test__get_domain_by_macs_not_found(self, libvirt_conn_mock): mgr_utils.mock_the_extension_manager(driver="fake_libvirt_fake") driver_factory.get_driver("fake_libvirt_fake") node = obj_utils.create_test_node( self.context, driver='fake_libvirt_fake', driver_info=_get_test_libvirt_driver_info('socket')) obj_utils.create_test_port(self.context, node_id=node.id, address='00:17:3a:50:12:12') with task_manager.acquire(self.context, node.uuid, shared=True) as task: self.assertRaises(exception.NodeNotFound, power._get_domain_by_macs, task)
def setUp(self): super(IPMINativeDriverTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="fake_ipminative") self.driver = driver_factory.get_driver("fake_ipminative") 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(ManagerTestCase, self).setUp() self.service = manager.ConductorManager('test-host', 'test-topic') self.context = context.get_admin_context() self.dbapi = dbapi.get_instance() mgr_utils.mock_the_extension_manager() self.driver = driver_factory.get_driver("fake")
def setUp(self): super(TaskManagerSetup, self).setUp() self.dbapi = dbapi.get_instance() self.context = context.get_admin_context() mgr_utils.mock_the_extension_manager() self.driver = driver_factory.get_driver("fake") self.config(host='test-host')
def setUp(self): super(UtilsTestCase, self).setUp() self.context = context.get_admin_context() self.dbapi = db_api.get_instance() mgr_utils.mock_the_extension_manager() self.driver = driver_factory.get_driver("fake") self.node = obj_utils.create_test_node(self.context)
def test__get_domain_by_macs(self, libvirt_conn_mock): mgr_utils.mock_the_extension_manager(driver="fake_libvirt_fake") driver_factory.get_driver("fake_libvirt_fake") node = obj_utils.create_test_node( self.context, driver='fake_libvirt_fake', driver_info=_get_test_libvirt_driver_info('socket')) obj_utils.create_test_port(self.context, node_id=node.id, address='00:16:3e:49:1d:11') with task_manager.acquire(self.context, node.uuid, shared=True) as task: domain = power._get_domain_by_macs(task) self.assertEqual('test_libvirt_domain', domain.name())
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 __init__(self, context, node_id, shared=False, driver_name=None, purpose='unspecified action'): """Create a new TaskManager. Acquire a lock on a node. The lock can be either shared or exclusive. Shared locks may be used for read-only or non-disruptive actions only, and must be considerate to what other threads may be doing on the same node at the same time. :param context: request context :param node_id: ID or UUID of node to lock. :param shared: Boolean indicating whether to take a shared or exclusive lock. Default: False. :param driver_name: The name of the driver to load, if different from the Node's current driver. :param purpose: human-readable purpose to put to debug logs. :raises: DriverNotFound :raises: NodeNotFound :raises: NodeLocked """ self._spawn_method = None self._on_error_method = None self.context = context self.node = None self.node_id = node_id self.shared = shared self.fsm = states.machine.copy() self._purpose = purpose self._debug_timer = timeutils.StopWatch() try: LOG.debug("Attempting to get %(type)s lock on node %(node)s (for " "%(purpose)s)", {'type': 'shared' if shared else 'exclusive', 'node': node_id, 'purpose': purpose}) if not self.shared: self._lock() else: self._debug_timer.restart() self.node = objects.Node.get(context, node_id) self.ports = objects.Port.list_by_node_id(context, self.node.id) self.driver = driver_factory.get_driver(driver_name or self.node.driver) # NOTE(deva): this handles the Juno-era NOSTATE state # and should be deleted after Kilo is released if self.node.provision_state is states.NOSTATE: self.node.provision_state = states.AVAILABLE self.node.save() self.fsm.initialize(start_state=self.node.provision_state, target_state=self.node.target_provision_state) except Exception: with excutils.save_and_reraise_exception(): self.release_resources()
def setUp(self): super(WakeOnLanPrivateMethodTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake_wol') self.driver = driver_factory.get_driver('fake_wol') self.node = obj_utils.create_test_node(self.context, driver='fake_wol') self.port = obj_utils.create_test_port(self.context, node_id=self.node.id)
def setUp(self): super(ServiceSetUpMixin, self).setUp() self.hostname = 'test-host' self.config(enabled_drivers=['fake']) self.config(node_locked_retry_attempts=1, group='conductor') self.config(node_locked_retry_interval=0, group='conductor') self.service = manager.ConductorManager(self.hostname, 'test-topic') mock_the_extension_manager() self.driver = driver_factory.get_driver("fake")
def setUp(self): super(IPMINativePowerMethodTestCase, self).setUp() self.context = context.get_admin_context() self.driver = driver_factory.get_driver("pxe_ipminative") self.node = obj_utils.create_test_node(self.context, driver='pxe_ipminative', driver_info=INFO_DICT) #self.dbapi = db_api.get_instance() self.info = ipminative._parse_driver_info(self.node)
def setUp(self): super(SSHDriverTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="fake_ssh") self.driver = driver_factory.get_driver("fake_ssh") self.node = obj_utils.create_test_node( self.context, driver="fake_ssh", driver_info=db_utils.get_test_ssh_info() ) self.port = obj_utils.create_test_port(self.context, node_id=self.node.id) self.sshclient = paramiko.SSHClient()
def setUp(self): super(IPMIToolDriverTestCase, self).setUp() self.context = context.get_admin_context() self.dbapi = db_api.get_instance() mgr_utils.mock_the_extension_manager(driver="fake_ipmitool") self.driver = driver_factory.get_driver("fake_ipmitool") self.node = obj_utils.create_test_node(self.context, driver="fake_ipmitool", driver_info=INFO_DICT) self.info = ipmi._parse_driver_info(self.node)
def test_node_set_boot_device_non_existent_device(self): mgr_utils.mock_the_extension_manager(driver="fake_ipmitool") self.driver = driver_factory.get_driver("fake_ipmitool") ipmi_info = utils.get_test_ipmi_info() node = obj_utils.create_test_node( self.context, uuid=uuidutils.generate_uuid(), driver="fake_ipmitool", driver_info=ipmi_info ) task = task_manager.TaskManager(self.context, node.uuid) self.assertRaises(exception.InvalidParameterValue, conductor_utils.node_set_boot_device, task, device="fake")
def setUp(self): super(IBootDriverTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake_iboot') self.driver = driver_factory.get_driver('fake_iboot') self.node = obj_utils.create_test_node( self.context, driver='fake_iboot', driver_info=INFO_DICT) self.info = iboot._parse_driver_info(self.node)
def setUp(self): super(FakeDriverTestCase, self).setUp() mgr_utils.mock_the_extension_manager() self.driver = driver_factory.get_driver("fake") self.node = obj_utils.get_test_node(self.context) self.task = mock.MagicMock(spec=task_manager.TaskManager) self.task.shared = False self.task.node = self.node self.task.driver = self.driver
def setUp(self): super(IRMCManagementTestCase, self).setUp() driver_info = INFO_DICT mgr_utils.mock_the_extension_manager(driver="fake_irmc") self.driver = driver_factory.get_driver("fake_irmc") self.node = obj_utils.create_test_node(self.context, driver='fake_irmc', driver_info=driver_info) self.info = irmc_common.parse_driver_info(self.node)
def setUp(self): super(BaseTestCase, self).setUp() self.config(enabled=True, group='discoverd') mgr_utils.mock_the_extension_manager("fake_discoverd") self.driver = driver_factory.get_driver("fake_discoverd") self.node = obj_utils.get_test_node(self.context) self.task = mock.Mock(spec=task_manager.TaskManager) self.task.context = mock.Mock() self.task.shared = False self.task.node = self.node self.task.driver = self.driver
def setUp(self): super(BaseTestCase, self).setUp() self.config(enabled=True, group='inspector') mgr_utils.mock_the_extension_manager("fake_inspector") self.driver = driver_factory.get_driver("fake_inspector") self.node = obj_utils.get_test_node(self.context) self.task = mock.MagicMock(spec=task_manager.TaskManager) self.task.context = mock.MagicMock(spec_set=['auth_token']) self.task.shared = False self.task.node = self.node self.task.driver = self.driver
def setUp(self): super(IBootDriverTestCase, self).setUp() self.config(max_retry=0, group='iboot') self.config(retry_interval=0, group='iboot') self.config(reboot_delay=0, group='iboot') mgr_utils.mock_the_extension_manager(driver='fake_iboot_fake') self.driver = driver_factory.get_driver('fake_iboot_fake') self.node = obj_utils.create_test_node( self.context, driver='fake_iboot_fake', driver_info=INFO_DICT) self.info = iboot_power._parse_driver_info(self.node)
def test_node_set_boot_device_non_existent_device(self): mgr_utils.mock_the_extension_manager(driver="fake_ipmitool") self.driver = driver_factory.get_driver("fake_ipmitool") ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(), driver='fake_ipmitool') node = self.dbapi.create_node(ndict) task = task_manager.TaskManager(self.context, node.uuid) self.assertRaises(exception.InvalidParameterValue, conductor_utils.node_set_boot_device, task, task.node, device='fake')
def setUp(self): super(IPMINativeDriverTestCase, self).setUp() self.context = context.get_admin_context() mgr_utils.mock_the_extension_manager(driver="fake_ipminative") self.driver = driver_factory.get_driver("fake_ipminative") n = db_utils.get_test_node( driver='fake_ipminative', driver_info=INFO_DICT) self.dbapi = db_api.get_instance() self.node = self.dbapi.create_node(n) self.info = ipminative._parse_driver_info(self.node)
def setUp(self): super(SeaMicroPowerDriverTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake_seamicro') self.driver = driver_factory.get_driver('fake_seamicro') self.node = obj_utils.create_test_node(self.context, driver='fake_seamicro', driver_info=INFO_DICT) self.get_server_patcher = mock.patch.object(seamicro, '_get_server') self.get_server_mock = None self.Server = Fake_Server self.Volume = Fake_Volume
def test_node_set_boot_device_valid(self): mgr_utils.mock_the_extension_manager(driver="fake_ipmitool") self.driver = driver_factory.get_driver("fake_ipmitool") ipmi_info = utils.get_test_ipmi_info() node = obj_utils.create_test_node( self.context, uuid=uuidutils.generate_uuid(), driver="fake_ipmitool", driver_info=ipmi_info ) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.management, "set_boot_device") as mock_sbd: conductor_utils.node_set_boot_device(task, device="pxe") mock_sbd.assert_called_once_with(task, device="pxe", persistent=False)
def setUp(self): super(IRMCManagementFunctionsTestCase, self).setUp() driver_info = INFO_DICT mgr_utils.mock_the_extension_manager(driver="fake_irmc") self.driver = driver_factory.get_driver("fake_irmc") self.node = obj_utils.create_test_node(self.context, driver='fake_irmc', driver_info=driver_info) self.info = irmc_common.parse_driver_info(self.node) irmc_management.irmc.scci.SCCIError = Exception irmc_management.irmc.scci.SCCIInvalidInputError = ValueError
def setUp(self): super(TestOneViewAgentDeploy, self).setUp() self.config( post_deploy_get_power_state_retries=GET_POWER_STATE_RETRIES, group='agent') mgr_utils.mock_the_extension_manager(driver="agent_pxe_oneview") self.driver = driver_factory.get_driver("agent_pxe_oneview") self.node = obj_utils.create_test_node( self.context, driver='agent_pxe_oneview', properties=db_utils.get_test_oneview_properties(), driver_info=db_utils.get_test_oneview_driver_info(), driver_internal_info={'agent_url': 'http://1.2.3.4:5678'}, )
def setUp(self): super(NodePowerActionTestCase, self).setUp() mgr_utils.mock_the_extension_manager() self.driver = driver_factory.get_driver("fake")
def test_get_driver_known(self): driver = driver_factory.get_driver('fake') self.assertIsInstance(driver, drivers_base.BaseDriver)
def __init__(self, context, node_id, shared=False, driver_name=None, purpose='unspecified action'): """Create a new TaskManager. Acquire a lock on a node. The lock can be either shared or exclusive. Shared locks may be used for read-only or non-disruptive actions only, and must be considerate to what other threads may be doing on the same node at the same time. :param context: request context :param node_id: ID or UUID of node to lock. :param shared: Boolean indicating whether to take a shared or exclusive lock. Default: False. :param driver_name: The name of the driver to load, if different from the Node's current driver. :param purpose: human-readable purpose to put to debug logs. :raises: DriverNotFound :raises: NodeNotFound :raises: NodeLocked """ self._spawn_method = None self._on_error_method = None self.context = context self.node = None self.node_id = node_id self.shared = shared self.fsm = states.machine.copy() self._purpose = purpose self._debug_timer = timeutils.StopWatch() try: LOG.debug( "Attempting to get %(type)s lock on node %(node)s (for " "%(purpose)s)", { 'type': 'shared' if shared else 'exclusive', 'node': node_id, 'purpose': purpose }) if not self.shared: self._lock() else: self._debug_timer.restart() self.node = objects.Node.get(context, node_id) self.ports = objects.Port.list_by_node_id(context, self.node.id) self.portgroups = objects.Portgroup.list_by_node_id( context, self.node.id) self.driver = driver_factory.get_driver(driver_name or self.node.driver) # NOTE(deva): this handles the Juno-era NOSTATE state # and should be deleted after Kilo is released if self.node.provision_state is states.NOSTATE: self.node.provision_state = states.AVAILABLE self.node.save() self.fsm.initialize(start_state=self.node.provision_state, target_state=self.node.target_provision_state) except Exception: with excutils.save_and_reraise_exception(): self.release_resources()
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 _do_mock(self): # NOTE(dtantsur): fake driver always has inspection, using another one mgr_utils.mock_the_extension_manager("pxe_ssh") self.driver = driver_factory.get_driver("pxe_ssh")
def __init__(self, context, node_id, shared=False, driver_name=None, purpose='unspecified action'): """Create a new TaskManager. Acquire a lock on a node. The lock can be either shared or exclusive. Shared locks may be used for read-only or non-disruptive actions only, and must be considerate to what other threads may be doing on the same node at the same time. :param context: request context :param node_id: ID or UUID of node to lock. :param shared: Boolean indicating whether to take a shared or exclusive lock. Default: False. :param driver_name: The name of the driver to load, if different from the Node's current driver. :param purpose: human-readable purpose to put to debug logs. :raises: DriverNotFound :raises: NodeNotFound :raises: NodeLocked """ self._spawn_method = None self._on_error_method = None self.context = context self.node = None self.shared = shared self.fsm = states.machine.copy() self._purpose = purpose self._debug_timer = time.time() # NodeLocked exceptions can be annoying. Let's try to alleviate # some of that pain by retrying our lock attempts. The retrying # module expects a wait_fixed value in milliseconds. @retrying.retry( retry_on_exception=lambda e: isinstance(e, exception.NodeLocked), stop_max_attempt_number=CONF.conductor.node_locked_retry_attempts, wait_fixed=CONF.conductor.node_locked_retry_interval * 1000) def reserve_node(): self.node = objects.Node.reserve(context, CONF.host, node_id) LOG.debug("Node %(node)s successfully reserved for %(purpose)s " "(took %(time).2f seconds)", {'node': node_id, 'purpose': purpose, 'time': time.time() - self._debug_timer}) self._debug_timer = time.time() try: LOG.debug("Attempting to get %(type)s lock on node %(node)s (for " "%(purpose)s)", {'type': 'shared' if shared else 'exclusive', 'node': node_id, 'purpose': purpose}) if not self.shared: reserve_node() else: self.node = objects.Node.get(context, node_id) self.ports = objects.Port.list_by_node_id(context, self.node.id) self.driver = driver_factory.get_driver(driver_name or self.node.driver) # NOTE(deva): this handles the Juno-era NOSTATE state # and should be deleted after Kilo is released if self.node.provision_state is states.NOSTATE: self.node.provision_state = states.AVAILABLE self.node.save() self.fsm.initialize(self.node.provision_state) except Exception: with excutils.save_and_reraise_exception(): self.release_resources()
def setUp(self): super(NodePowerActionTestCase, self).setUp() self.context = context.get_admin_context() self.dbapi = dbapi.get_instance() mgr_utils.mock_the_extension_manager() self.driver = driver_factory.get_driver("fake")
def _do_mock(self): # NOTE(dtantsur): fake driver always has inspection, using another one self.config(enabled_drivers=['pxe_ipmitool']) self.driver = driver_factory.get_driver("pxe_ipmitool")