def test_discover_hosts(self):
status = lambda m: None
ctxt = context.get_admin_context()
# NOTE(danms): Three cells, one unmapped host per cell
mappings = host_mapping.discover_hosts(ctxt, status_fn=status)
self.assertEqual(3, len(mappings))
# NOTE(danms): All hosts should be mapped now, so we should do
# no lookups for them
with mock.patch('nova.objects.HostMapping.get_by_host') as mock_gbh:
mappings = host_mapping.discover_hosts(ctxt, status_fn=status)
self.assertFalse(mock_gbh.called)
self.assertEqual(0, len(mappings))
def test_discover_services_one_cell(self, mock_srv, mock_hm_create,
mock_hm_get, mock_cm):
mock_cm.return_value = objects.CellMapping(uuid=uuids.cell1)
mock_srv.return_value = [
objects.Service(host='host1'),
objects.Service(host='host2'),
]
def fake_get_host_mapping(ctxt, host):
if host == 'host2':
return
else:
raise exception.HostMappingNotFound(name=host)
mock_hm_get.side_effect = fake_get_host_mapping
lines = []
def fake_status(msg):
lines.append(msg)
ctxt = context.get_admin_context()
mappings = host_mapping.discover_hosts(ctxt, cell_uuid=uuids.cell1,
status_fn=fake_status,
by_service=True)
self.assertEqual(1, len(mappings))
self.assertEqual(['host1'],
sorted([m.host for m in mappings]))
expected = """\
Getting computes from cell: %(cell)s
Creating host mapping for service host1
Found 1 unmapped computes in cell: %(cell)s""" % {'cell': uuids.cell1}
self.assertEqual(expected, '\n'.join(lines))
def test_discover_services(self, mock_srv, mock_hm_create,
mock_hm_get, mock_cm):
mock_cm.return_value = [
objects.CellMapping(uuid=uuids.cell1),
objects.CellMapping(uuid=uuids.cell2),
]
mock_srv.side_effect = [
[objects.Service(host='host1'),
objects.Service(host='host2')],
[objects.Service(host='host3')],
]
def fake_get_host_mapping(ctxt, host):
if host == 'host2':
return
else:
raise exception.HostMappingNotFound(name=host)
mock_hm_get.side_effect = fake_get_host_mapping
ctxt = context.get_admin_context()
mappings = host_mapping.discover_hosts(ctxt, by_service=True)
self.assertEqual(2, len(mappings))
self.assertEqual(['host1', 'host3'],
sorted([m.host for m in mappings]))
def test_discover_hosts_one(self, mock_cn_get, mock_hm_get, mock_hm_create,
mock_cm):
def _hm_get(context, host):
if host in ['a', 'b', 'c']:
return objects.HostMapping()
raise exception.HostMappingNotFound(name=host)
mock_hm_get.side_effect = _hm_get
# NOTE(danms): Provide both side effects, but expect it to only
# be called once if we provide a cell
mock_cn_get.side_effect = [[objects.ComputeNode(host='d',
uuid=uuids.cn1)],
[objects.ComputeNode(host='e',
uuid=uuids.cn2)]]
mock_cm.return_value = objects.CellMapping(name='foo',
uuid=uuids.cm1)
ctxt = context.get_admin_context()
with mock.patch('nova.objects.ComputeNode.save') as mock_save:
hms = host_mapping.discover_hosts(ctxt, uuids.cm1)
mock_save.assert_called_once_with()
self.assertEqual(1, len(hms))
self.assertTrue(mock_hm_create.called)
self.assertEqual(['d'],
[hm.host for hm in hms])
def test_discover_hosts_all(self, mock_cn_get, mock_hm_get, mock_hm_create,
mock_cm):
def _hm_get(context, host):
if host in ['a', 'b', 'c']:
return objects.HostMapping()
raise exception.HostMappingNotFound(name=host)
mock_hm_get.side_effect = _hm_get
mock_cn_get.side_effect = [[objects.ComputeNode(host='d',
uuid=uuids.cn1)],
[objects.ComputeNode(host='e',
uuid=uuids.cn2)]]
cell_mappings = [objects.CellMapping(name='foo',
uuid=uuids.cm1),
objects.CellMapping(name='bar',
uuid=uuids.cm2)]
mock_cm.return_value = cell_mappings
ctxt = context.get_admin_context()
with mock.patch('nova.objects.ComputeNode.save') as mock_save:
hms = host_mapping.discover_hosts(ctxt)
mock_save.assert_has_calls([mock.call(), mock.call()])
self.assertEqual(2, len(hms))
self.assertTrue(mock_hm_create.called)
self.assertEqual(['d', 'e'],
[hm.host for hm in hms])
def test_discover_services_one_cell(self, mock_srv, mock_hm_create,
mock_hm_get, mock_cm):
mock_cm.return_value = objects.CellMapping(uuid=uuids.cell1)
mock_srv.return_value = [
objects.Service(host='host1'),
objects.Service(host='host2'),
]
def fake_get_host_mapping(ctxt, host):
if host == 'host2':
return
else:
raise exception.HostMappingNotFound(name=host)
mock_hm_get.side_effect = fake_get_host_mapping
lines = []
def fake_status(msg):
lines.append(msg)
ctxt = context.get_admin_context()
mappings = host_mapping.discover_hosts(ctxt, cell_uuid=uuids.cell1,
status_fn=fake_status,
by_service=True)
self.assertEqual(1, len(mappings))
self.assertEqual(['host1'],
sorted([m.host for m in mappings]))
expected = """\
Getting computes from cell: %(cell)s
Creating host mapping for service host1
Found 1 unmapped computes in cell: %(cell)s""" % {'cell': uuids.cell1}
self.assertEqual(expected, '\n'.join(lines))
def test_discover_services(self, mock_srv, mock_hm_create,
mock_hm_get, mock_cm):
mock_cm.return_value = [
objects.CellMapping(uuid=uuids.cell1),
objects.CellMapping(uuid=uuids.cell2),
]
mock_srv.side_effect = [
[objects.Service(host='host1'),
objects.Service(host='host2')],
[objects.Service(host='host3')],
]
def fake_get_host_mapping(ctxt, host):
if host == 'host2':
return
else:
raise exception.HostMappingNotFound(name=host)
mock_hm_get.side_effect = fake_get_host_mapping
ctxt = context.get_admin_context()
mappings = host_mapping.discover_hosts(ctxt, by_service=True)
self.assertEqual(2, len(mappings))
self.assertEqual(['host1', 'host3'],
sorted([m.host for m in mappings]))
def test_discover_hosts_one(self, mock_cn_get, mock_hm_get, mock_hm_create,
mock_cm):
def _hm_get(context, host):
if host in ['a', 'b', 'c']:
return objects.HostMapping()
raise exception.HostMappingNotFound(name=host)
mock_hm_get.side_effect = _hm_get
# NOTE(danms): Provide both side effects, but expect it to only
# be called once if we provide a cell
mock_cn_get.side_effect = [[objects.ComputeNode(host='d',
uuid=uuids.cn1)],
[objects.ComputeNode(host='e',
uuid=uuids.cn2)]]
mock_cm.return_value = objects.CellMapping(name='foo',
uuid=uuids.cm1)
ctxt = context.get_admin_context()
with mock.patch('nova.objects.ComputeNode.save') as mock_save:
hms = host_mapping.discover_hosts(ctxt, uuids.cm1)
mock_save.assert_called_once_with()
self.assertEqual(1, len(hms))
self.assertTrue(mock_hm_create.called)
self.assertEqual(['d'],
[hm.host for hm in hms])
def test_discover_hosts_all(self, mock_cn_get, mock_hm_get, mock_hm_create,
mock_cm):
def _hm_get(context, host):
if host in ['a', 'b', 'c']:
return objects.HostMapping()
raise exception.HostMappingNotFound(name=host)
mock_hm_get.side_effect = _hm_get
mock_cn_get.side_effect = [[objects.ComputeNode(host='d',
uuid=uuids.cn1)],
[objects.ComputeNode(host='e',
uuid=uuids.cn2)]]
cell_mappings = [objects.CellMapping(name='foo',
uuid=uuids.cm1),
objects.CellMapping(name='bar',
uuid=uuids.cm2)]
mock_cm.return_value = cell_mappings
ctxt = context.get_admin_context()
with mock.patch('nova.objects.ComputeNode.save') as mock_save:
hms = host_mapping.discover_hosts(ctxt)
mock_save.assert_has_calls([mock.call(), mock.call()])
self.assertEqual(2, len(hms))
self.assertTrue(mock_hm_create.called)
self.assertEqual(['d', 'e'],
[hm.host for hm in hms])
def _discover_hosts_in_cells(self, context):
global HOST_MAPPING_EXISTS_WARNING
try:
host_mappings = host_mapping_obj.discover_hosts(context)
if host_mappings:
LOG.info(
'Discovered %(count)i new hosts: %(hosts)s',
{
'count':
len(host_mappings),
'hosts':
','.join([
'%s:%s' % (hm.cell_mapping.name, hm.host)
for hm in host_mappings
]),
},
)
except exception.HostMappingExists as exp:
msg = ('This periodic task should only be enabled on a single '
'scheduler to prevent collisions between multiple '
'schedulers: %s' % str(exp))
if not HOST_MAPPING_EXISTS_WARNING:
LOG.warning(msg)
HOST_MAPPING_EXISTS_WARNING = True
else:
LOG.debug(msg)
def _discover_hosts_in_cells(self, context):
host_mappings = host_mapping_obj.discover_hosts(context)
if host_mappings:
LOG.info('Discovered %(count)i new hosts: %(hosts)s',
{'count': len(host_mappings),
'hosts': ','.join(['%s:%s' % (hm.cell_mapping.name,
hm.host)
for hm in host_mappings])})
def _discover_hosts_in_cells(self, context):
host_mappings = host_mapping_obj.discover_hosts(context)
if host_mappings:
LOG.info('Discovered %(count)i new hosts: %(hosts)s',
{'count': len(host_mappings),
'hosts': ','.join(['%s:%s' % (hm.cell_mapping.name,
hm.host)
for hm in host_mappings])})
def test_discover_hosts_one_cell(self):
status = lambda m: None
ctxt = context.get_admin_context()
cells = objects.CellMappingList.get_all(ctxt)
# NOTE(danms): One cell, one unmapped host per cell
mappings = host_mapping.discover_hosts(ctxt, cells[1].uuid,
status_fn=status)
self.assertEqual(1, len(mappings))
# NOTE(danms): Three cells, two with one more unmapped host
mappings = host_mapping.discover_hosts(ctxt, status_fn=status)
self.assertEqual(2, len(mappings))
# NOTE(danms): All hosts should be mapped now, so we should do
# no lookups for them
with mock.patch('nova.objects.HostMapping.get_by_host') as mock_gbh:
mappings = host_mapping.discover_hosts(ctxt, status_fn=status)
self.assertFalse(mock_gbh.called)
self.assertEqual(0, len(mappings))
def test_discover_hosts_one_cell(self):
status = lambda m: None
ctxt = context.get_admin_context()
cells = objects.CellMappingList.get_all(ctxt)
# NOTE(danms): One cell, one unmapped host per cell
mappings = host_mapping.discover_hosts(ctxt,
cells[1].uuid,
status_fn=status)
self.assertEqual(1, len(mappings))
# NOTE(danms): Three cells, two with one more unmapped host
mappings = host_mapping.discover_hosts(ctxt, status_fn=status)
self.assertEqual(2, len(mappings))
# NOTE(danms): All hosts should be mapped now, so we should do
# no lookups for them
with mock.patch('nova.objects.HostMapping.get_by_host') as mock_gbh:
mappings = host_mapping.discover_hosts(ctxt, status_fn=status)
self.assertFalse(mock_gbh.called)
self.assertEqual(0, len(mappings))
