def test_acquire_non_blocking(self, get_lock_mock): node_info = node_cache.NodeInfo(self.uuid) self.assertFalse(node_info._locked) get_lock_mock.return_value.acquire.side_effect = iter([False, True]) self.assertFalse(node_info.acquire_lock(blocking=False)) self.assertFalse(node_info._locked) self.assertTrue(node_info.acquire_lock(blocking=False)) self.assertTrue(node_info._locked) self.assertTrue(node_info.acquire_lock(blocking=False)) self.assertTrue(node_info._locked) get_lock_mock.return_value.acquire.assert_called_with(False) self.assertEqual(2, get_lock_mock.return_value.acquire.call_count)
def setUp(self): super(TestValidateInterfacesHookBeforeUpdateDeletion, self).setUp() self.hook = std_plugins.ValidateInterfacesHook() self.interfaces_to_create = sorted(self.valid_interfaces.values(), key=lambda i: i['mac']) self.existing_ports = [ mock.Mock(spec=['address', 'uuid'], address=a) for a in (self.macs[1], '44:44:44:44:44:44') ] self.node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=0, node=self.node, ports=self.existing_ports)
def setUp(self): super(TestSchedulerHook, self).setUp() self.hook = std_plugins.SchedulerHook() self.data = { 'local_gb': 20, 'memory_mb': 1024, 'cpus': 2, 'cpu_arch': 'x86_64' } self.node_patches = [] self.ports_patches = {} self.node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=0, node=self.node)
def setUp(self): super(TestProcessNode, self).setUp() CONF.set_override('processing_hooks', '$processing.default_processing_hooks,example', 'processing') self.validate_attempts = 5 self.data['macs'] = self.macs # validate_interfaces hook self.data['all_interfaces'] = self.data['interfaces'] self.ports = self.all_ports self.node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=self.started_at, node=self.node) self.patch_props = [{ 'path': '/properties/cpus', 'value': '2', 'op': 'add' }, { 'path': '/properties/cpu_arch', 'value': 'x86_64', 'op': 'add' }, { 'path': '/properties/memory_mb', 'value': '1024', 'op': 'add' }, { 'path': '/properties/local_gb', 'value': '20', 'op': 'add' }] # scheduler hook self.new_creds = ('user', 'password') self.patch_credentials = [ { 'op': 'add', 'path': '/driver_info/ipmi_username', 'value': self.new_creds[0] }, { 'op': 'add', 'path': '/driver_info/ipmi_password', 'value': self.new_creds[1] }, ] self.cli = mock.Mock() self.cli.node.get_boot_device.side_effect = ( [RuntimeError()] * self.validate_attempts + [None]) self.cli.port.create.side_effect = self.ports self.cli.node.update.return_value = self.node self.cli.node.list_ports.return_value = []
def test_add_attribute_same_value(self): session = db.get_session() with session.begin(): db.Node(uuid=self.node.uuid, state=istate.States.starting).save(session) node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=42) node_info.add_attribute('key', 'value') node_info.add_attribute('key', 'value') res = db.model_query(db.Attribute.name, db.Attribute.value, db.Attribute.node_uuid, session=session) self.assertEqual([('key', 'value', self.uuid), ('key', 'value', self.uuid)], [tuple(row) for row in res])
def setUp(self): super(BaseProcessTest, self).setUp() self.cache_fixture = self.useFixture( fixtures.MockPatchObject(node_cache, 'find_node', autospec=True)) self.process_fixture = self.useFixture( fixtures.MockPatchObject(process, '_process_node', autospec=True)) self.find_mock = self.cache_fixture.mock self.node_info = node_cache.NodeInfo(uuid=self.node.uuid, started_at=self.started_at) self.node_info.finished = mock.Mock() self.find_mock.return_value = self.node_info self.cli.node.get.return_value = self.node self.process_mock = self.process_fixture.mock self.process_mock.return_value = self.fake_result_json
def test_no_overwrite(self, mock_patch): ports = [ mock.Mock(spec=['address', 'uuid', 'physical_network'], address=a, physical_network='foo') for a in ('11:11:11:11:11:11', ) ] node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=0, node=self.node, ports=ports) cfg.CONF.set_override('overwrite_existing', False, group='processing') cfg.CONF.set_override('cidr_map', '1.1.1.0/24:physnet_a', group='port_physnet') self.hook.before_update(self.data, node_info) self.assertFalse(mock_patch.called)
def setUp(self): super(TestValidateInterfacesHookBeforeUpdatePXEEnabled, self).setUp() self.hook = std_plugins.ValidateInterfacesHook() # Note(milan) assumes the ordering of self.macs from test_base.NodeTest # where the first item '11:22:33:44:55:66' is the MAC of the # self.pxe_iface_name 'eth1', the "real" PXE interface sorted_interfaces = sorted(self.valid_interfaces.values(), key=lambda i: i['mac']) self.existing_ports = [ mock.Mock(spec=['address', 'uuid', 'pxe_enabled'], address=iface['mac'], pxe_enabled=True) for iface in sorted_interfaces ] self.node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=0, node=self.node, ports=self.existing_ports)
def test_add_attribute(self): session = db.get_session() with session.begin(): db.Node(uuid=self.node.uuid).save(session) node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=42) node_info.add_attribute('key', 'value') res = db.model_query(db.Attribute.name, db.Attribute.value, db.Attribute.uuid, session=session) res = res.order_by(db.Attribute.name, db.Attribute.value).all() self.assertEqual([('key', 'value', self.uuid)], [tuple(row) for row in res]) self.assertRaises(utils.Error, node_info.add_attribute, 'key', 'value') # check that .attributes got invalidated and reloaded self.assertEqual({'key': ['value']}, node_info.attributes)
def setUp(self): super(TestReapplyNode, self).setUp() CONF.set_override('processing_hooks', '$processing.default_processing_hooks,example', 'processing') CONF.set_override('store_data', 'swift', 'processing') self.data['macs'] = self.macs self.ports = self.all_ports self.node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=self.started_at, node=self.node) self.node_info.invalidate_cache = mock.Mock() self.new_creds = ('user', 'password') self.cli.port.create.side_effect = self.ports self.cli.node.update.return_value = self.node self.cli.node.list_ports.return_value = []
def setUp(self): super(TestNuageLocalLinkConnectionHook, self).setUp() self.data = { 'inventory': { 'interfaces': [{ 'name': 'enp2s0', 'mac_address': '0c:c4:7a:4a:f1:82', 'ipv4_address': '192.168.10.12', 'lldp': [(0, ''), (1, '046854ed016d00'), (2, '073337383437303430'), (3, '0079'), (4, '312d4769672045746865726e657420534650'), (5, '7673672d69726f6e6963'), (7, '00140014'), (8, '05010a1efe020200000001280000000100000003000000' '060000000100000004000000010000197f000000010000' '001200000001')] }], 'cpu': 1, 'disks': 1, 'memory': 1 }, 'all_interfaces': { 'enp2s0': {}, } } llc = {'port_id': '56'} ports = [ mock.Mock(spec=['address', 'uuid', 'local_link_connection'], address=a, local_link_connection=llc) for a in ('0c:c4:7a:4a:f1:82', ) ] self.node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=0, node=self.node, ports=ports)
def setUp(self): super(TestValidateInterfacesHook, self).setUp() self.hook = std_plugins.ValidateInterfacesHook() self.data = { 'interfaces': { 'em1': { 'mac': '11:11:11:11:11:11', 'ip': '1.1.1.1' }, 'em2': { 'mac': '22:22:22:22:22:22', 'ip': '2.2.2.2' }, 'em3': { 'mac': '33:33:33:33:33:33' } }, 'boot_interface': '01-22-22-22-22-22-22', } self.orig_interfaces = self.data['interfaces'].copy() self.pxe_interface = self.data['interfaces']['em2'] self.active_interfaces = { 'em1': { 'mac': '11:11:11:11:11:11', 'ip': '1.1.1.1' }, 'em2': { 'mac': '22:22:22:22:22:22', 'ip': '2.2.2.2' }, } self.existing_ports = [ mock.Mock(spec=['address', 'uuid'], address=a) for a in ('11:11:11:11:11:11', '44:44:44:44:44:44') ] self.node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=0, node=self.node, ports=self.existing_ports)
def setUp(self): super(TestSystemNameLocalLinkConnectionHook, self).setUp() self.data = { 'inventory': { 'interfaces': [{ 'name': 'em1', 'mac_address': '11:11:11:11:11:11', 'ipv4_address': '1.1.1.1', 'lldp': [ (0, ''), (5, '7377697463682d31') # switch-1 ] }], 'cpu': 1, 'disks': 1, 'memory': 1 }, 'all_interfaces': { 'em1': {}, } } llc = {'switch_info': 'switch-2'} ports = [ mock.Mock(spec=['address', 'uuid', 'local_link_connection'], address=a, local_link_connection=llc) for a in ('11:11:11:11:11:11', ) ] self.node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=0, node=self.node, ports=ports)
def setUp(self): super(BaseTest, self).setUp() self.uuid = 'uuid' self.conditions_json = [ { 'op': 'eq', 'field': 'memory_mb', 'value': 1024 }, { 'op': 'eq', 'field': 'local_gb', 'value': 60 }, ] self.actions_json = [{'action': 'fail', 'message': 'boom!'}] self.data = { 'memory_mb': 1024, 'local_gb': 42, } self.node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=42)
def setUp(self): super(TestBasePortPhysnetHook, self).setUp() self.data = { 'inventory': { 'interfaces': [{ 'name': 'em1', 'mac_address': '11:11:11:11:11:11', 'ipv4_address': '1.1.1.1', }], 'cpu': 1, 'disks': 1, 'memory': 1 }, 'all_interfaces': { 'em1': {}, } } ports = [mock.Mock(spec=['address', 'uuid', 'physical_network'], address=a, physical_network='physnet1') for a in ('11:11:11:11:11:11',)] self.node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=0, node=self.node, ports=ports)
def setUp(self): super(NodeTest, self).setUp() self.uuid = '1a1a1a1a-2b2b-3c3c-4d4d-5e5e5e5e5e5e' self.bmc_address = '1.2.3.4' self.macs = ['11:22:33:44:55:66', '66:55:44:33:22:11'] self.node = mock.Mock(driver='pxe_ipmitool', driver_info={'ipmi_address': self.bmc_address}, properties={ 'cpu_arch': 'i386', 'local_gb': 40 }, uuid=self.uuid, power_state='power on', provision_state='inspecting', extra={}, instance_uuid=None, maintenance=False) self.ports = [] self.node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=0, node=self.node, ports=self.ports)
def setUp(self): super(TestGenericLocalLinkConnectionHook, self).setUp() self.data = { 'inventory': { 'interfaces': [{ 'name': 'em1', 'mac_address': '11:11:11:11:11:11', 'ipv4_address': '1.1.1.1', 'lldp': [(0, ''), (1, '04885a92ec5459'), (2, '0545746865726e6574312f3138'), (3, '0078')] }], 'cpu': 1, 'disks': 1, 'memory': 1 }, 'all_interfaces': { 'em1': {}, } } llc = {'port_id': '56'} ports = [ mock.Mock(spec=['address', 'uuid', 'local_link_connection'], address=a, local_link_connection=llc) for a in ('11:11:11:11:11:11', ) ] self.node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=0, node=self.node, ports=ports)
def setUp(self): super(TestReapplyNode, self).setUp() CONF.set_override('processing_hooks', '$processing.default_processing_hooks,example', 'processing') CONF.set_override('store_data', 'swift', 'processing') self.data['macs'] = self.macs self.ports = self.all_ports self.node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=self.started_at, node=self.node) self.node_info.invalidate_cache = mock.Mock() self.cli.port.create.side_effect = self.ports self.cli.node.update.return_value = self.node self.cli.node.list_ports.return_value = [] self.node_info._state = istate.States.finished self.commit_fixture = self.useFixture( fixtures.MockPatchObject(node_cache.NodeInfo, 'commit', autospec=True)) db.Node(uuid=self.node_info.uuid, state=self.node_info._state, started_at=self.node_info.started_at, finished_at=self.node_info.finished_at, error=self.node_info.error).save(self.session)
def setUp(self): super(TestSchedulerHook, self).setUp() self.hook = std_plugins.SchedulerHook() self.node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=0, node=self.node)
def test_ports_provided_list(self, mock_ironic): node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=0, ports=list(self.ports.values())) self.assertEqual(self.ports, node_info.ports()) self.assertFalse(mock_ironic.called)
def test_ports_provided(self, mock_ironic): node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=0, ports=self.ports) self.assertIs(self.ports, node_info.ports()) self.assertFalse(mock_ironic.called)
def test_node_provided(self, mock_ironic): node_info = node_cache.NodeInfo(uuid=self.uuid, started_at=0, node=mock.sentinel.node) self.assertIs(mock.sentinel.node, node_info.node()) self.assertFalse(mock_ironic.called)
def wrapper(self, pop_mock, *args, **kw): pop_mock.return_value = node_cache.NodeInfo( uuid=self.node.uuid, started_at=self.started_at) pop_mock.return_value.finished = mock.Mock() pop_mock.return_value.acquire_lock = mock.Mock() return func(self, pop_mock, *args, **kw)
def test_prefix_NodeInfo_instance_with_state(self): node_info = node_cache.NodeInfo('NNN', state='foobar') self.assertEqual('[node: NNN state foobar]', utils.processing_logger_prefix(node_info=node_info))
def test_prefix_NodeInfo_instance(self): node_info = node_cache.NodeInfo('NNN') self.assertEqual('[node: NNN]', utils.processing_logger_prefix(node_info=node_info))