2018 lines
82 KiB
Python
2018 lines
82 KiB
Python
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
import ddt
|
|
import mock
|
|
import os_resource_classes as orc
|
|
from oslo_serialization import jsonutils
|
|
from oslo_utils.fixture import uuidsentinel as uuids
|
|
|
|
from nova import context as nova_context
|
|
from nova import exception
|
|
from nova import objects
|
|
from nova.scheduler.client import report
|
|
from nova.scheduler import utils
|
|
from nova import test
|
|
from nova.tests.unit import fake_instance
|
|
from nova.tests.unit.scheduler import fakes
|
|
|
|
|
|
class FakeResourceRequest(object):
|
|
"""A fake of ``nova.scheduler.utils.ResourceRequest``.
|
|
|
|
Allows us to assert that various properties of a real ResourceRequest
|
|
object are set as we'd like them to be.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self._rg_by_id = {}
|
|
self._group_policy = None
|
|
self._limit = 1000
|
|
|
|
|
|
class TestUtilsBase(test.NoDBTestCase):
|
|
def setUp(self):
|
|
super(TestUtilsBase, self).setUp()
|
|
self.context = nova_context.get_admin_context()
|
|
self.mock_host_manager = mock.Mock()
|
|
|
|
def assertResourceRequestsEqual(self, expected, observed):
|
|
self.assertEqual(expected._limit, observed._limit)
|
|
self.assertEqual(expected._group_policy, observed._group_policy)
|
|
ex_by_id = expected._rg_by_id
|
|
ob_by_id = observed._rg_by_id
|
|
self.assertEqual(set(ex_by_id), set(ob_by_id))
|
|
for ident in ex_by_id:
|
|
self.assertEqual(vars(ex_by_id[ident]), vars(ob_by_id[ident]))
|
|
|
|
|
|
@ddt.ddt
|
|
class TestUtils(TestUtilsBase):
|
|
|
|
def _test_resources_from_request_spec(self, expected, flavor, image=None):
|
|
if image is None:
|
|
image = objects.ImageMeta(properties=objects.ImageMetaProps())
|
|
fake_spec = objects.RequestSpec(flavor=flavor, image=image)
|
|
resources = utils.resources_from_request_spec(
|
|
self.context, fake_spec, self.mock_host_manager)
|
|
self.assertResourceRequestsEqual(expected, resources)
|
|
return resources
|
|
|
|
def test_resources_from_request_spec_flavor_only(self):
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=5,
|
|
swap=0)
|
|
expected_resources = FakeResourceRequest()
|
|
expected_resources._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
}
|
|
)
|
|
self._test_resources_from_request_spec(expected_resources, flavor)
|
|
|
|
def test_resources_from_request_spec_flavor_req_traits(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs={'trait:CUSTOM_FLAVOR_TRAIT': 'required'})
|
|
expected_resources = FakeResourceRequest()
|
|
expected_resources._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
required_traits=set(['CUSTOM_FLAVOR_TRAIT'])
|
|
)
|
|
resources = self._test_resources_from_request_spec(
|
|
expected_resources, flavor)
|
|
expected_result = set(['CUSTOM_FLAVOR_TRAIT'])
|
|
self.assertEqual(expected_result, resources.all_required_traits)
|
|
|
|
def test_resources_from_request_spec_flavor_and_image_traits(self):
|
|
image = objects.ImageMeta.from_dict({
|
|
'properties': {
|
|
'trait:CUSTOM_IMAGE_TRAIT1': 'required',
|
|
'trait:CUSTOM_IMAGE_TRAIT2': 'required',
|
|
},
|
|
'id': 'c8b1790e-a07d-4971-b137-44f2432936cd',
|
|
})
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=5,
|
|
swap=0,
|
|
extra_specs={
|
|
'trait:CUSTOM_FLAVOR_TRAIT': 'required',
|
|
'trait:CUSTOM_IMAGE_TRAIT2': 'required'})
|
|
expected_resources = FakeResourceRequest()
|
|
expected_resources._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
required_traits={
|
|
# trait:CUSTOM_IMAGE_TRAIT2 is defined in both extra_specs and
|
|
# image metadata. We get a union of both.
|
|
'CUSTOM_IMAGE_TRAIT1',
|
|
'CUSTOM_IMAGE_TRAIT2',
|
|
'CUSTOM_FLAVOR_TRAIT',
|
|
}
|
|
)
|
|
self._test_resources_from_request_spec(expected_resources, flavor,
|
|
image)
|
|
|
|
def test_resources_from_request_spec_flavor_forbidden_trait(self):
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=5,
|
|
swap=0,
|
|
extra_specs={
|
|
'trait:CUSTOM_FLAVOR_TRAIT': 'forbidden'})
|
|
expected_resources = FakeResourceRequest()
|
|
expected_resources._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
forbidden_traits={
|
|
'CUSTOM_FLAVOR_TRAIT',
|
|
}
|
|
)
|
|
self._test_resources_from_request_spec(expected_resources, flavor)
|
|
|
|
def test_resources_from_request_spec_with_no_disk(self):
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=0,
|
|
ephemeral_gb=0,
|
|
swap=0)
|
|
expected_resources = FakeResourceRequest()
|
|
expected_resources._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
}
|
|
)
|
|
self._test_resources_from_request_spec(expected_resources, flavor)
|
|
|
|
def test_get_resources_from_request_spec_custom_resource_class(self):
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=5,
|
|
swap=0,
|
|
extra_specs={"resources:CUSTOM_TEST_CLASS": 1})
|
|
expected_resources = FakeResourceRequest()
|
|
expected_resources._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
"VCPU": 1,
|
|
"MEMORY_MB": 1024,
|
|
"DISK_GB": 15,
|
|
"CUSTOM_TEST_CLASS": 1,
|
|
}
|
|
)
|
|
self._test_resources_from_request_spec(expected_resources, flavor)
|
|
|
|
def test_get_resources_from_request_spec_override_flavor_amounts(self):
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=5,
|
|
swap=0,
|
|
extra_specs={
|
|
"resources:VCPU": 99,
|
|
"resources:MEMORY_MB": 99,
|
|
"resources:DISK_GB": 99})
|
|
expected_resources = FakeResourceRequest()
|
|
expected_resources._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
"VCPU": 99,
|
|
"MEMORY_MB": 99,
|
|
"DISK_GB": 99,
|
|
}
|
|
)
|
|
self._test_resources_from_request_spec(expected_resources, flavor)
|
|
|
|
def test_get_resources_from_request_spec_remove_flavor_amounts(self):
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=5,
|
|
swap=0,
|
|
extra_specs={
|
|
"resources:VCPU": 0,
|
|
"resources:DISK_GB": 0})
|
|
expected_resources = FakeResourceRequest()
|
|
expected_resources._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
"MEMORY_MB": 1024,
|
|
}
|
|
)
|
|
self._test_resources_from_request_spec(expected_resources, flavor)
|
|
|
|
def test_get_resources_from_request_spec_vgpu(self):
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=0,
|
|
swap=0,
|
|
extra_specs={
|
|
"resources:VGPU": 1,
|
|
"resources:VGPU_DISPLAY_HEAD": 1})
|
|
expected_resources = FakeResourceRequest()
|
|
expected_resources._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
"VCPU": 1,
|
|
"MEMORY_MB": 1024,
|
|
"DISK_GB": 10,
|
|
"VGPU": 1,
|
|
"VGPU_DISPLAY_HEAD": 1,
|
|
}
|
|
)
|
|
self._test_resources_from_request_spec(expected_resources, flavor)
|
|
|
|
def test_get_resources_from_request_spec_bad_std_resource_class(self):
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=5,
|
|
swap=0,
|
|
extra_specs={
|
|
"resources:DOESNT_EXIST": 0})
|
|
fake_spec = objects.RequestSpec(flavor=flavor)
|
|
with mock.patch("nova.objects.request_spec.LOG.warning") as mock_log:
|
|
utils.resources_from_request_spec(
|
|
self.context, fake_spec, self.mock_host_manager)
|
|
mock_log.assert_called_once()
|
|
args = mock_log.call_args[0]
|
|
self.assertEqual(args[0], "Received an invalid ResourceClass "
|
|
"'%(key)s' in extra_specs.")
|
|
self.assertEqual(args[1], {"key": "DOESNT_EXIST"})
|
|
|
|
def test_get_resources_from_request_spec_granular(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=0, swap=0,
|
|
extra_specs={'resources1:VGPU': '1',
|
|
'resources1:VGPU_DISPLAY_HEAD': '2',
|
|
# Replace
|
|
'resources3:VCPU': '2',
|
|
# Stay separate (don't sum)
|
|
'resources42:SRIOV_NET_VF': '1',
|
|
'resources24:SRIOV_NET_VF': '2',
|
|
# Ignore
|
|
'some:bogus': 'value',
|
|
# Custom in the unnumbered group (merge with DISK_GB)
|
|
'resources:CUSTOM_THING': '123',
|
|
# Traits make it through
|
|
'trait3:CUSTOM_SILVER': 'required',
|
|
'trait3:CUSTOM_GOLD': 'required',
|
|
# Delete standard
|
|
'resources86:MEMORY_MB': '0',
|
|
# Standard and custom zeroes don't make it through
|
|
'resources:IPV4_ADDRESS': '0',
|
|
'resources:CUSTOM_FOO': '0',
|
|
# Bogus values don't make it through
|
|
'resources1:MEMORY_MB': 'bogus',
|
|
'group_policy': 'none'})
|
|
expected_resources = FakeResourceRequest()
|
|
expected_resources._group_policy = 'none'
|
|
expected_resources._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'DISK_GB': 10,
|
|
'CUSTOM_THING': 123,
|
|
}
|
|
)
|
|
expected_resources._rg_by_id['1'] = objects.RequestGroup(
|
|
requester_id='1',
|
|
resources={
|
|
'VGPU': 1,
|
|
'VGPU_DISPLAY_HEAD': 2,
|
|
}
|
|
)
|
|
expected_resources._rg_by_id['3'] = objects.RequestGroup(
|
|
requester_id='3',
|
|
resources={
|
|
'VCPU': 2,
|
|
},
|
|
required_traits={
|
|
'CUSTOM_GOLD',
|
|
'CUSTOM_SILVER',
|
|
}
|
|
)
|
|
expected_resources._rg_by_id['24'] = objects.RequestGroup(
|
|
requester_id='24',
|
|
resources={
|
|
'SRIOV_NET_VF': 2,
|
|
},
|
|
)
|
|
expected_resources._rg_by_id['42'] = objects.RequestGroup(
|
|
requester_id='42',
|
|
resources={
|
|
'SRIOV_NET_VF': 1,
|
|
}
|
|
)
|
|
|
|
rr = self._test_resources_from_request_spec(expected_resources, flavor)
|
|
expected_querystring = (
|
|
'group_policy=none&'
|
|
'limit=1000&'
|
|
'required3=CUSTOM_GOLD%2CCUSTOM_SILVER&'
|
|
'resources=CUSTOM_THING%3A123%2CDISK_GB%3A10&'
|
|
'resources1=VGPU%3A1%2CVGPU_DISPLAY_HEAD%3A2&'
|
|
'resources24=SRIOV_NET_VF%3A2&'
|
|
'resources3=VCPU%3A2&'
|
|
'resources42=SRIOV_NET_VF%3A1'
|
|
)
|
|
self.assertEqual(expected_querystring, rr.to_querystring())
|
|
|
|
def test_all_required_traits(self):
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=5,
|
|
swap=0,
|
|
extra_specs={
|
|
'trait:HW_CPU_X86_SSE': 'required',
|
|
'trait:HW_CPU_X86_AVX': 'required',
|
|
'trait:HW_CPU_X86_AVX2': 'forbidden'})
|
|
expected_resources = FakeResourceRequest()
|
|
expected_resources._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
required_traits={
|
|
'HW_CPU_X86_SSE',
|
|
'HW_CPU_X86_AVX'
|
|
},
|
|
forbidden_traits={
|
|
'HW_CPU_X86_AVX2'
|
|
}
|
|
)
|
|
resource = self._test_resources_from_request_spec(expected_resources,
|
|
flavor)
|
|
expected_result = {'HW_CPU_X86_SSE', 'HW_CPU_X86_AVX'}
|
|
self.assertEqual(expected_result,
|
|
resource.all_required_traits)
|
|
|
|
def test_resources_from_request_spec_aggregates(self):
|
|
destination = objects.Destination()
|
|
flavor = objects.Flavor(vcpus=1, memory_mb=1024,
|
|
root_gb=1, ephemeral_gb=0,
|
|
swap=0)
|
|
reqspec = objects.RequestSpec(flavor=flavor,
|
|
requested_destination=destination)
|
|
|
|
destination.require_aggregates(['foo', 'bar'])
|
|
req = utils.resources_from_request_spec(
|
|
self.context, reqspec, self.mock_host_manager)
|
|
self.assertEqual([['foo', 'bar']],
|
|
req.get_request_group(None).aggregates)
|
|
|
|
destination.require_aggregates(['baz'])
|
|
req = utils.resources_from_request_spec(
|
|
self.context, reqspec, self.mock_host_manager)
|
|
self.assertEqual([['foo', 'bar'], ['baz']],
|
|
req.get_request_group(None).aggregates)
|
|
|
|
def test_resources_from_request_spec_no_aggregates(self):
|
|
flavor = objects.Flavor(vcpus=1, memory_mb=1024,
|
|
root_gb=1, ephemeral_gb=0,
|
|
swap=0)
|
|
reqspec = objects.RequestSpec(flavor=flavor)
|
|
|
|
req = utils.resources_from_request_spec(
|
|
self.context, reqspec, self.mock_host_manager)
|
|
self.assertEqual([], req.get_request_group(None).aggregates)
|
|
|
|
reqspec.requested_destination = None
|
|
req = utils.resources_from_request_spec(
|
|
self.context, reqspec, self.mock_host_manager)
|
|
self.assertEqual([], req.get_request_group(None).aggregates)
|
|
|
|
reqspec.requested_destination = objects.Destination()
|
|
req = utils.resources_from_request_spec(
|
|
self.context, reqspec, self.mock_host_manager)
|
|
self.assertEqual([], req.get_request_group(None).aggregates)
|
|
|
|
reqspec.requested_destination.aggregates = None
|
|
req = utils.resources_from_request_spec(
|
|
self.context, reqspec, self.mock_host_manager)
|
|
self.assertEqual([], req.get_request_group(None).aggregates)
|
|
|
|
def test_resources_from_request_spec_forbidden_aggregates(self):
|
|
flavor = objects.Flavor(vcpus=1, memory_mb=1024,
|
|
root_gb=1, ephemeral_gb=0,
|
|
swap=0)
|
|
reqspec = objects.RequestSpec(
|
|
flavor=flavor,
|
|
requested_destination=objects.Destination(
|
|
forbidden_aggregates=set(['foo', 'bar'])))
|
|
|
|
req = utils.resources_from_request_spec(self.context, reqspec,
|
|
self.mock_host_manager)
|
|
self.assertEqual(set(['foo', 'bar']),
|
|
req.get_request_group(None).forbidden_aggregates)
|
|
|
|
def test_resources_from_request_spec_no_forbidden_aggregates(self):
|
|
flavor = objects.Flavor(vcpus=1, memory_mb=1024,
|
|
root_gb=1, ephemeral_gb=0,
|
|
swap=0)
|
|
reqspec = objects.RequestSpec(flavor=flavor)
|
|
|
|
req = utils.resources_from_request_spec(
|
|
self.context, reqspec, self.mock_host_manager)
|
|
self.assertEqual(set([]), req.get_request_group(None).
|
|
forbidden_aggregates)
|
|
|
|
reqspec.requested_destination = None
|
|
req = utils.resources_from_request_spec(
|
|
self.context, reqspec, self.mock_host_manager)
|
|
self.assertEqual(set([]), req.get_request_group(None).
|
|
forbidden_aggregates)
|
|
|
|
reqspec.requested_destination = objects.Destination()
|
|
req = utils.resources_from_request_spec(
|
|
self.context, reqspec, self.mock_host_manager)
|
|
self.assertEqual(set([]), req.get_request_group(None).
|
|
forbidden_aggregates)
|
|
|
|
reqspec.requested_destination.forbidden_aggregates = None
|
|
req = utils.resources_from_request_spec(
|
|
self.context, reqspec, self.mock_host_manager)
|
|
self.assertEqual(set([]), req.get_request_group(None).
|
|
forbidden_aggregates)
|
|
|
|
def test_process_extra_specs_granular_called(self):
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=5,
|
|
swap=0,
|
|
extra_specs={"resources:CUSTOM_TEST_CLASS": 1})
|
|
fake_spec = objects.RequestSpec(flavor=flavor)
|
|
# just call this to make sure things don't explode
|
|
utils.resources_from_request_spec(
|
|
self.context, fake_spec, self.mock_host_manager)
|
|
|
|
def test_process_extra_specs_granular_not_called(self):
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=5,
|
|
swap=0)
|
|
fake_spec = objects.RequestSpec(flavor=flavor)
|
|
# just call this to make sure things don't explode
|
|
utils.resources_from_request_spec(
|
|
self.context, fake_spec, self.mock_host_manager)
|
|
|
|
def test_process_missing_extra_specs_value(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=5,
|
|
swap=0,
|
|
extra_specs={"resources:CUSTOM_TEST_CLASS": ""})
|
|
fake_spec = objects.RequestSpec(flavor=flavor)
|
|
# just call this to make sure things don't explode
|
|
utils.resources_from_request_spec(
|
|
self.context, fake_spec, self.mock_host_manager)
|
|
|
|
def test_process_no_force_hosts_or_force_nodes(self):
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=15,
|
|
ephemeral_gb=0,
|
|
swap=0)
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
)
|
|
rr = self._test_resources_from_request_spec(expected, flavor)
|
|
expected_querystring = (
|
|
'limit=1000&'
|
|
'resources=DISK_GB%3A15%2CMEMORY_MB%3A1024%2CVCPU%3A1'
|
|
)
|
|
self.assertEqual(expected_querystring, rr.to_querystring())
|
|
|
|
def test_process_use_force_nodes(self):
|
|
fake_nodes = objects.ComputeNodeList(objects=[
|
|
objects.ComputeNode(host='fake-host',
|
|
uuid='12345678-1234-1234-1234-123456789012',
|
|
hypervisor_hostname='test')])
|
|
self.mock_host_manager.get_compute_nodes_by_host_or_node.\
|
|
return_value = fake_nodes
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=15,
|
|
ephemeral_gb=0,
|
|
swap=0)
|
|
fake_spec = objects.RequestSpec(flavor=flavor, force_nodes=['test'])
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
in_tree='12345678-1234-1234-1234-123456789012',
|
|
)
|
|
resources = utils.resources_from_request_spec(
|
|
self.context, fake_spec, self.mock_host_manager)
|
|
self.assertResourceRequestsEqual(expected, resources)
|
|
expected_querystring = (
|
|
'in_tree=12345678-1234-1234-1234-123456789012&'
|
|
'limit=1000&resources=DISK_GB%3A15%2CMEMORY_MB%3A1024%2CVCPU%3A1')
|
|
self.assertEqual(expected_querystring, resources.to_querystring())
|
|
self.mock_host_manager.get_compute_nodes_by_host_or_node.\
|
|
assert_called_once_with(self.context, None, 'test', cell=None)
|
|
|
|
def test_process_use_force_hosts(self):
|
|
fake_nodes = objects.ComputeNodeList(objects=[
|
|
objects.ComputeNode(host='test',
|
|
uuid='12345678-1234-1234-1234-123456789012')
|
|
])
|
|
self.mock_host_manager.get_compute_nodes_by_host_or_node.\
|
|
return_value = fake_nodes
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=15,
|
|
ephemeral_gb=0,
|
|
swap=0)
|
|
fake_spec = objects.RequestSpec(flavor=flavor, force_hosts=['test'])
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
in_tree='12345678-1234-1234-1234-123456789012',
|
|
)
|
|
resources = utils.resources_from_request_spec(
|
|
self.context, fake_spec, self.mock_host_manager)
|
|
self.assertResourceRequestsEqual(expected, resources)
|
|
expected_querystring = (
|
|
'in_tree=12345678-1234-1234-1234-123456789012&'
|
|
'limit=1000&resources=DISK_GB%3A15%2CMEMORY_MB%3A1024%2CVCPU%3A1')
|
|
self.assertEqual(expected_querystring, resources.to_querystring())
|
|
self.mock_host_manager.get_compute_nodes_by_host_or_node.\
|
|
assert_called_once_with(self.context, 'test', None, cell=None)
|
|
|
|
def test_process_use_force_hosts_multinodes_found(self):
|
|
fake_nodes = objects.ComputeNodeList(objects=[
|
|
objects.ComputeNode(host='test',
|
|
uuid='12345678-1234-1234-1234-123456789012'),
|
|
objects.ComputeNode(host='test',
|
|
uuid='87654321-4321-4321-4321-210987654321'),
|
|
])
|
|
self.mock_host_manager.get_compute_nodes_by_host_or_node.\
|
|
return_value = fake_nodes
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=15,
|
|
ephemeral_gb=0,
|
|
swap=0)
|
|
fake_spec = objects.RequestSpec(flavor=flavor, force_hosts=['test'])
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
)
|
|
# Validate that the limit is unset
|
|
expected._limit = None
|
|
|
|
resources = utils.resources_from_request_spec(
|
|
self.context, fake_spec, self.mock_host_manager)
|
|
self.assertResourceRequestsEqual(expected, resources)
|
|
# Validate that the limit is unset
|
|
expected_querystring = (
|
|
'resources=DISK_GB%3A15%2CMEMORY_MB%3A1024%2CVCPU%3A1')
|
|
self.assertEqual(expected_querystring, resources.to_querystring())
|
|
self.mock_host_manager.get_compute_nodes_by_host_or_node.\
|
|
assert_called_once_with(self.context, 'test', None, cell=None)
|
|
|
|
def test_process_use_requested_destination(self):
|
|
fake_cell = objects.CellMapping(uuid=uuids.cell1, name='foo')
|
|
destination = objects.Destination(
|
|
host='fake-host', node='fake-node', cell=fake_cell)
|
|
fake_nodes = objects.ComputeNodeList(objects=[
|
|
objects.ComputeNode(host='fake-host',
|
|
uuid='12345678-1234-1234-1234-123456789012',
|
|
hypervisor_hostname='fake-node')
|
|
])
|
|
self.mock_host_manager.get_compute_nodes_by_host_or_node.\
|
|
return_value = fake_nodes
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=15,
|
|
ephemeral_gb=0,
|
|
swap=0)
|
|
fake_spec = objects.RequestSpec(
|
|
flavor=flavor, requested_destination=destination)
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
in_tree='12345678-1234-1234-1234-123456789012',
|
|
)
|
|
resources = utils.resources_from_request_spec(
|
|
self.context, fake_spec, self.mock_host_manager)
|
|
self.assertResourceRequestsEqual(expected, resources)
|
|
expected_querystring = (
|
|
'in_tree=12345678-1234-1234-1234-123456789012&'
|
|
'limit=1000&resources=DISK_GB%3A15%2CMEMORY_MB%3A1024%2CVCPU%3A1')
|
|
self.assertEqual(expected_querystring, resources.to_querystring())
|
|
self.mock_host_manager.get_compute_nodes_by_host_or_node.\
|
|
assert_called_once_with(
|
|
self.context, 'fake-host', 'fake-node', cell=fake_cell)
|
|
|
|
def test_resources_from_request_spec_having_requested_resources(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=5,
|
|
swap=0)
|
|
rg1 = objects.RequestGroup(
|
|
resources={'CUSTOM_FOO': 1}, requester_id='The-first-group')
|
|
|
|
# Leave requester_id out to trigger ValueError
|
|
rg2 = objects.RequestGroup(required_traits={'CUSTOM_BAR'})
|
|
|
|
reqspec = objects.RequestSpec(flavor=flavor,
|
|
requested_resources=[rg1, rg2])
|
|
|
|
self.assertRaises(
|
|
ValueError,
|
|
utils.resources_from_request_spec,
|
|
self.context, reqspec, self.mock_host_manager)
|
|
|
|
# Set conflicting requester_id
|
|
rg2.requester_id = 'The-first-group'
|
|
self.assertRaises(
|
|
exception.RequestGroupSuffixConflict,
|
|
utils.resources_from_request_spec,
|
|
self.context, reqspec, self.mock_host_manager)
|
|
|
|
# Good path: nonempty non-conflicting requester_id
|
|
rg2.requester_id = 'The-second-group'
|
|
|
|
req = utils.resources_from_request_spec(
|
|
self.context, reqspec, self.mock_host_manager)
|
|
self.assertEqual({'MEMORY_MB': 1024, 'DISK_GB': 15, 'VCPU': 1},
|
|
req.get_request_group(None).resources)
|
|
self.assertIs(rg1, req.get_request_group('The-first-group'))
|
|
self.assertIs(rg2, req.get_request_group('The-second-group'))
|
|
# Make sure those ended up as suffixes correctly
|
|
qs = req.to_querystring()
|
|
self.assertIn('resourcesThe-first-group=CUSTOM_FOO%3A1', qs)
|
|
self.assertIn('requiredThe-second-group=CUSTOM_BAR', qs)
|
|
|
|
def test_resources_from_request_spec_requested_resources_unfilled(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=5,
|
|
swap=0)
|
|
reqspec = objects.RequestSpec(flavor=flavor)
|
|
req = utils.resources_from_request_spec(
|
|
self.context, reqspec, self.mock_host_manager)
|
|
self.assertEqual({'MEMORY_MB': 1024, 'DISK_GB': 15, 'VCPU': 1},
|
|
req.get_request_group(None).resources)
|
|
self.assertEqual(1, len(list(req._rg_by_id)))
|
|
|
|
reqspec = objects.RequestSpec(flavor=flavor, requested_resources=[])
|
|
req = utils.resources_from_request_spec(
|
|
self.context, reqspec, self.mock_host_manager)
|
|
self.assertEqual({'MEMORY_MB': 1024, 'DISK_GB': 15, 'VCPU': 1},
|
|
req.get_request_group(None).resources)
|
|
self.assertEqual(1, len(list(req._rg_by_id)))
|
|
|
|
@ddt.data(
|
|
# Test single hint that we are checking for.
|
|
{'group': [uuids.fake]},
|
|
# Test hint we care about and some other random hint.
|
|
{'same_host': [uuids.fake], 'fake-hint': ['fake-value']},
|
|
# Test multiple hints we are checking for.
|
|
{'same_host': [uuids.server1], 'different_host': [uuids.server2]})
|
|
def test_resources_from_request_spec_no_limit_based_on_hint(self, hints):
|
|
"""Tests that there is no limit applied to the
|
|
GET /allocation_candidates query string if a given scheduler hint
|
|
is in the request spec.
|
|
"""
|
|
flavor = objects.Flavor(vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=15,
|
|
ephemeral_gb=0,
|
|
swap=0)
|
|
fake_spec = objects.RequestSpec(
|
|
flavor=flavor, scheduler_hints=hints)
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
)
|
|
expected._limit = None
|
|
resources = utils.resources_from_request_spec(
|
|
self.context, fake_spec, self.mock_host_manager)
|
|
self.assertResourceRequestsEqual(expected, resources)
|
|
expected_querystring = (
|
|
'resources=DISK_GB%3A15%2CMEMORY_MB%3A1024%2CVCPU%3A1'
|
|
)
|
|
self.assertEqual(expected_querystring, resources.to_querystring())
|
|
|
|
@mock.patch('nova.compute.utils.is_volume_backed_instance',
|
|
return_value=False)
|
|
def test_resources_from_flavor_no_bfv(self, mock_is_bfv):
|
|
flavor = objects.Flavor(vcpus=1, memory_mb=1024, root_gb=10,
|
|
ephemeral_gb=5, swap=1024,
|
|
extra_specs={})
|
|
instance = objects.Instance()
|
|
expected = {
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 16,
|
|
}
|
|
actual = utils.resources_from_flavor(instance, flavor)
|
|
self.assertEqual(expected, actual)
|
|
|
|
@mock.patch('nova.compute.utils.is_volume_backed_instance',
|
|
return_value=True)
|
|
def test_resources_from_flavor_bfv(self, mock_is_bfv):
|
|
flavor = objects.Flavor(vcpus=1, memory_mb=1024, root_gb=10,
|
|
ephemeral_gb=5, swap=1024,
|
|
extra_specs={})
|
|
instance = objects.Instance()
|
|
expected = {
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 6, # No root disk...
|
|
}
|
|
actual = utils.resources_from_flavor(instance, flavor)
|
|
self.assertEqual(expected, actual)
|
|
|
|
@mock.patch('nova.compute.utils.is_volume_backed_instance',
|
|
new=mock.Mock(return_value=False))
|
|
def test_resources_from_flavor_with_override(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=1024,
|
|
extra_specs={
|
|
# Replace
|
|
'resources:VCPU': '2',
|
|
# Sum up
|
|
'resources42:SRIOV_NET_VF': '1',
|
|
'resources24:SRIOV_NET_VF': '2',
|
|
# Ignore
|
|
'some:bogus': 'value',
|
|
# Custom
|
|
'resources:CUSTOM_THING': '123',
|
|
# Ignore
|
|
'trait:CUSTOM_GOLD': 'required',
|
|
# Delete standard
|
|
'resources86:MEMORY_MB': 0,
|
|
# Standard and custom zeroes don't make it through
|
|
'resources:IPV4_ADDRESS': 0,
|
|
'resources:CUSTOM_FOO': 0,
|
|
'group_policy': 'none'})
|
|
instance = objects.Instance()
|
|
expected = {
|
|
'VCPU': 2,
|
|
'DISK_GB': 16,
|
|
'CUSTOM_THING': 123,
|
|
'SRIOV_NET_VF': 3,
|
|
}
|
|
actual = utils.resources_from_flavor(instance, flavor)
|
|
self.assertEqual(expected, actual)
|
|
|
|
def test_resource_request_from_request_spec(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0)
|
|
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
)
|
|
rs = objects.RequestSpec(flavor=flavor, is_bfv=False)
|
|
rr = utils.ResourceRequest.from_request_spec(rs)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
|
|
def test_resource_request_from_request_spec_with_extra_specs(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs={
|
|
'resources:VCPU': '2',
|
|
'resources:MEMORY_MB': '2048',
|
|
'trait:HW_CPU_X86_AVX': 'required',
|
|
# Key skipped because no colons
|
|
'nocolons': '42',
|
|
'trait:CUSTOM_MAGIC': 'required',
|
|
'trait:CUSTOM_BRONZE': 'forbidden',
|
|
# Resource skipped because invalid resource class name
|
|
'resources86:CUTSOM_MISSPELLED': '86',
|
|
'resources1:SRIOV_NET_VF': '1',
|
|
# Resource skipped because non-int-able value
|
|
'resources86:CUSTOM_FOO': 'seven',
|
|
# Resource skipped because negative value
|
|
'resources86:CUSTOM_NEGATIVE': '-7',
|
|
'resources1:IPV4_ADDRESS': '1',
|
|
# Trait skipped because unsupported value
|
|
'trait86:CUSTOM_GOLD': 'preferred',
|
|
'trait1:CUSTOM_PHYSNET_NET1': 'required',
|
|
'trait1:CUSTOM_PHYSNET_NET2': 'forbidden',
|
|
'resources2:SRIOV_NET_VF': '1',
|
|
'resources2:IPV4_ADDRESS': '2',
|
|
'trait2:CUSTOM_PHYSNET_NET2': 'required',
|
|
'trait2:HW_NIC_ACCEL_SSL': 'required',
|
|
# Groupings that don't quite match the patterns are ignored
|
|
'resources_*5:SRIOV_NET_VF': '7',
|
|
'traitFoo$:HW_NIC_ACCEL_SSL': 'required',
|
|
# Solo resource, no corresponding traits
|
|
'resources3:DISK_GB': '5',
|
|
'group_policy': 'isolate',
|
|
})
|
|
|
|
expected = FakeResourceRequest()
|
|
expected._group_policy = 'isolate'
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 2,
|
|
'MEMORY_MB': 2048,
|
|
},
|
|
required_traits={
|
|
'HW_CPU_X86_AVX',
|
|
'CUSTOM_MAGIC',
|
|
},
|
|
forbidden_traits={
|
|
'CUSTOM_BRONZE',
|
|
},
|
|
)
|
|
expected._rg_by_id['1'] = objects.RequestGroup(
|
|
requester_id='1',
|
|
resources={
|
|
'SRIOV_NET_VF': 1,
|
|
'IPV4_ADDRESS': 1,
|
|
},
|
|
required_traits={
|
|
'CUSTOM_PHYSNET_NET1',
|
|
},
|
|
forbidden_traits={
|
|
'CUSTOM_PHYSNET_NET2',
|
|
},
|
|
)
|
|
expected._rg_by_id['2'] = objects.RequestGroup(
|
|
requester_id='2',
|
|
resources={
|
|
'SRIOV_NET_VF': 1,
|
|
'IPV4_ADDRESS': 2,
|
|
},
|
|
required_traits={
|
|
'CUSTOM_PHYSNET_NET2',
|
|
'HW_NIC_ACCEL_SSL',
|
|
}
|
|
)
|
|
expected._rg_by_id['3'] = objects.RequestGroup(
|
|
requester_id='3',
|
|
resources={
|
|
'DISK_GB': 5,
|
|
}
|
|
)
|
|
|
|
rs = objects.RequestSpec(flavor=flavor, is_bfv=False)
|
|
rr = utils.ResourceRequest.from_request_spec(rs)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
expected_querystring = (
|
|
'group_policy=isolate&'
|
|
'limit=1000&'
|
|
'required=CUSTOM_MAGIC%2CHW_CPU_X86_AVX%2C%21CUSTOM_BRONZE&'
|
|
'required1=CUSTOM_PHYSNET_NET1%2C%21CUSTOM_PHYSNET_NET2&'
|
|
'required2=CUSTOM_PHYSNET_NET2%2CHW_NIC_ACCEL_SSL&'
|
|
'resources=MEMORY_MB%3A2048%2CVCPU%3A2&'
|
|
'resources1=IPV4_ADDRESS%3A1%2CSRIOV_NET_VF%3A1&'
|
|
'resources2=IPV4_ADDRESS%3A2%2CSRIOV_NET_VF%3A1&'
|
|
'resources3=DISK_GB%3A5'
|
|
)
|
|
self.assertEqual(expected_querystring, rr.to_querystring())
|
|
|
|
def _test_resource_request_from_rs_with_legacy_extra_specs(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs={
|
|
'hw:cpu_policy': 'dedicated',
|
|
'hw:cpu_thread_policy': 'isolate',
|
|
'hw:emulator_threads_policy': 'isolate',
|
|
})
|
|
|
|
return objects.RequestSpec(flavor=flavor, is_bfv=False)
|
|
|
|
def test_resource_request_from_request_spec_with_legacy_extra_specs(self):
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
# we should have two PCPUs, one due to hw:cpu_policy and the
|
|
# other due to hw:cpu_thread_policy
|
|
'PCPU': 2,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
forbidden_traits={
|
|
# we should forbid hyperthreading due to hw:cpu_thread_policy
|
|
'HW_CPU_HYPERTHREADING',
|
|
},
|
|
)
|
|
rs = self._test_resource_request_from_rs_with_legacy_extra_specs()
|
|
rr = utils.ResourceRequest.from_request_spec(rs)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
self.assertTrue(rr.cpu_pinning_requested)
|
|
|
|
def test_resource_request_from_rs_with_legacy_extra_specs_no_translate(
|
|
self
|
|
):
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
# we should have a VCPU despite hw:cpu_policy because
|
|
# enable_pinning_translate=False
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
# we should not require hyperthreading despite hw:cpu_thread_policy
|
|
# because enable_pinning_translate=False
|
|
forbidden_traits=set(),
|
|
)
|
|
rs = self._test_resource_request_from_rs_with_legacy_extra_specs()
|
|
rr = utils.ResourceRequest.from_request_spec(
|
|
rs, enable_pinning_translate=False)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
self.assertFalse(rr.cpu_pinning_requested)
|
|
|
|
def test_resource_request_from_request_spec_with_image_props(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0)
|
|
image = objects.ImageMeta.from_dict({
|
|
'properties': {
|
|
'trait:CUSTOM_TRUSTED': 'required',
|
|
},
|
|
'id': 'c8b1790e-a07d-4971-b137-44f2432936cd'
|
|
})
|
|
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
required_traits={
|
|
'CUSTOM_TRUSTED',
|
|
}
|
|
)
|
|
rs = objects.RequestSpec(flavor=flavor, image=image, is_bfv=False)
|
|
rr = utils.ResourceRequest.from_request_spec(rs)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
|
|
def _test_resource_request_from_rs_with_legacy_image_props(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0)
|
|
image = objects.ImageMeta.from_dict({
|
|
'properties': {
|
|
'hw_cpu_policy': 'dedicated',
|
|
'hw_cpu_thread_policy': 'require',
|
|
},
|
|
'id': 'c8b1790e-a07d-4971-b137-44f2432936cd',
|
|
})
|
|
return objects.RequestSpec(flavor=flavor, image=image, is_bfv=False)
|
|
|
|
def test_resource_request_from_request_spec_with_legacy_image_props(self):
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
# we should have a PCPU due to hw_cpu_policy
|
|
'PCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
required_traits={
|
|
# we should require hyperthreading due to hw_cpu_thread_policy
|
|
'HW_CPU_HYPERTHREADING',
|
|
},
|
|
)
|
|
rs = self._test_resource_request_from_rs_with_legacy_image_props()
|
|
rr = utils.ResourceRequest.from_request_spec(rs)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
self.assertTrue(rr.cpu_pinning_requested)
|
|
|
|
def test_resource_request_from_rs_with_legacy_image_props_no_translate(
|
|
self
|
|
):
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
# we should have a VCPU despite hw_cpu_policy because
|
|
# enable_pinning_translate=False
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
# we should not require hyperthreading despite hw_cpu_thread_policy
|
|
# because enable_pinning_translate=False
|
|
required_traits=set(),
|
|
)
|
|
rs = self._test_resource_request_from_rs_with_legacy_image_props()
|
|
rr = utils.ResourceRequest.from_request_spec(
|
|
rs, enable_pinning_translate=False)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
self.assertFalse(rr.cpu_pinning_requested)
|
|
|
|
def _test_resource_request_from_request_spec_with_mixed_cpus(
|
|
self, extra_specs
|
|
):
|
|
flavor = objects.Flavor(
|
|
vcpus=4, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs=extra_specs)
|
|
rs = objects.RequestSpec(flavor=flavor)
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'PCPU': 2,
|
|
'VCPU': 2,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
required_traits=set(),
|
|
)
|
|
rr = utils.ResourceRequest.from_request_spec(rs)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
|
|
def test_resource_request_from_request_spec_with_mixed_cpus_dedicated(
|
|
self
|
|
):
|
|
"""Ensure the mixed instance, which is generated through
|
|
'hw:cpu_dedicated_mask' extra spec, properly requests the PCPU, VCPU,
|
|
MEMORY_MB and DISK_GB resources.
|
|
"""
|
|
extra_specs = {
|
|
'hw:cpu_policy': 'mixed',
|
|
'hw:cpu_dedicated_mask': '2,3'
|
|
}
|
|
self._test_resource_request_from_request_spec_with_mixed_cpus(
|
|
extra_specs)
|
|
|
|
def test_resource_request_from_request_spec_with_mixed_cpus_realtime(self):
|
|
"""Ensure the mixed instance, which is generated through real-time CPU
|
|
interface, properly requests the PCPU, VCPU, MEMORY_BM and DISK_GB
|
|
resources.
|
|
"""
|
|
extra_specs = {
|
|
'hw:cpu_policy': 'mixed',
|
|
"hw:cpu_realtime": "yes",
|
|
"hw:cpu_realtime_mask": '2,3'
|
|
}
|
|
self._test_resource_request_from_request_spec_with_mixed_cpus(
|
|
extra_specs)
|
|
|
|
def _test_resource_request_from_request_spec_with_mixed_cpus_iso_emu(
|
|
self, extra_specs
|
|
):
|
|
flavor = objects.Flavor(
|
|
vcpus=4, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs=extra_specs)
|
|
rs = objects.RequestSpec(flavor=flavor)
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
# An extra PCPU resource is requested due to 'ISOLATE' emulator
|
|
# thread policy.
|
|
'PCPU': 3,
|
|
'VCPU': 2,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
required_traits=set(),
|
|
)
|
|
rr = utils.ResourceRequest.from_request_spec(rs)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
|
|
def test_resource_request_from_rswith_mixed_cpus_iso_emu_realtime(self):
|
|
"""Ensure the mixed instance, which is generated through the
|
|
'hw:cpu_dedicated_mask' extra spec, specs, properly requests the PCPU,
|
|
VCPU, MEMORY_MB, DISK_GB resources, ensure an extra PCPU resource is
|
|
requested due to a ISOLATE emulator thread policy.
|
|
"""
|
|
extra_specs = {
|
|
'hw:cpu_policy': 'mixed',
|
|
'hw:cpu_dedicated_mask': '2,3',
|
|
'hw:emulator_threads_policy': 'isolate',
|
|
}
|
|
self._test_resource_request_from_request_spec_with_mixed_cpus_iso_emu(
|
|
extra_specs)
|
|
|
|
def test_resource_request_from_rs_with_mixed_cpus_iso_emu_dedicated(self):
|
|
"""Ensure the mixed instance, which is generated through realtime extra
|
|
specs, properly requests the PCPU, VCPU, MEMORY_MB, DISK_GB resources,
|
|
ensure an extra PCPU resource is requested due to a ISOLATE emulator
|
|
thread policy.
|
|
"""
|
|
extra_specs = {
|
|
'hw:cpu_policy': 'mixed',
|
|
"hw:cpu_realtime": "yes",
|
|
"hw:cpu_realtime_mask": '2,3',
|
|
'hw:emulator_threads_policy': 'isolate',
|
|
}
|
|
self._test_resource_request_from_request_spec_with_mixed_cpus_iso_emu(
|
|
extra_specs)
|
|
|
|
def test_resource_request_from_request_spec_is_bfv(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=1555)
|
|
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
# this should only include the ephemeral and swap disk, and the
|
|
# latter should be converted from MB to GB and rounded up
|
|
'DISK_GB': 7,
|
|
},
|
|
)
|
|
rs = objects.RequestSpec(flavor=flavor, is_bfv=True)
|
|
rr = utils.ResourceRequest.from_request_spec(rs)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
|
|
def test_resource_request_from_request_spec_with_vpmems(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs={'hw:pmem': '4GB, 4GB,SMALL'})
|
|
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
'CUSTOM_PMEM_NAMESPACE_4GB': 2,
|
|
'CUSTOM_PMEM_NAMESPACE_SMALL': 1
|
|
},
|
|
)
|
|
rs = objects.RequestSpec(flavor=flavor, is_bfv=False)
|
|
rr = utils.ResourceRequest.from_request_spec(rs)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
|
|
def test_resource_request_from_request_spec_with_pci_numa_policy(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs={'hw:pci_numa_affinity_policy': 'socket'},
|
|
)
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
required_traits={'COMPUTE_SOCKET_PCI_NUMA_AFFINITY'},
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
)
|
|
rs = objects.RequestSpec(flavor=flavor, is_bfv=False)
|
|
rr = utils.ResourceRequest.from_request_spec(rs)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
|
|
def test_resource_request_from_request_spec_with_secure_boot(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs={'os:secure_boot': 'required'},
|
|
)
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
required_traits={'COMPUTE_SECURITY_UEFI_SECURE_BOOT'},
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
)
|
|
rs = objects.RequestSpec(flavor=flavor, is_bfv=False)
|
|
rr = utils.ResourceRequest.from_request_spec(rs)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
|
|
def test_resource_request_from_request_spec_with_vtpm_1_2(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs={'hw:tpm_version': '1.2', 'hw:tpm_model': 'tpm-tis'},
|
|
)
|
|
image = objects.ImageMeta(
|
|
properties=objects.ImageMetaProps(
|
|
hw_tpm_version='1.2',
|
|
hw_tpm_model='tpm-tis',
|
|
)
|
|
)
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
required_traits={'COMPUTE_SECURITY_TPM_1_2'},
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
)
|
|
rs = objects.RequestSpec(flavor=flavor, image=image, is_bfv=False)
|
|
rr = utils.ResourceRequest.from_request_spec(rs)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
|
|
def test_resource_request_from_request_spec_with_vtpm_2_0(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs={'hw:tpm_version': '2.0', 'hw:tpm_model': 'tpm-crb'},
|
|
)
|
|
image = objects.ImageMeta(
|
|
properties=objects.ImageMetaProps(
|
|
hw_tpm_version='2.0',
|
|
hw_tpm_model='tpm-crb',
|
|
)
|
|
)
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
required_traits={'COMPUTE_SECURITY_TPM_2_0'},
|
|
resources={
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
},
|
|
)
|
|
rs = objects.RequestSpec(flavor=flavor, image=image, is_bfv=False)
|
|
rr = utils.ResourceRequest.from_request_spec(rs)
|
|
self.assertResourceRequestsEqual(expected, rr)
|
|
|
|
def test_resource_request_from_request_group(self):
|
|
rg = objects.RequestGroup.from_port_request(
|
|
self.context,
|
|
uuids.port_id,
|
|
port_resource_request={
|
|
"resources": {
|
|
"NET_BW_IGR_KILOBIT_PER_SEC": 1000,
|
|
"NET_BW_EGR_KILOBIT_PER_SEC": 1000},
|
|
"required": ["CUSTOM_PHYSNET_2",
|
|
"CUSTOM_VNIC_TYPE_NORMAL"]
|
|
}
|
|
)
|
|
|
|
rr = utils.ResourceRequest.from_request_group(rg)
|
|
|
|
self.assertEqual(
|
|
f'limit=1000&'
|
|
f'required{uuids.port_id}='
|
|
f'CUSTOM_PHYSNET_2%2C'
|
|
f'CUSTOM_VNIC_TYPE_NORMAL&'
|
|
f'resources{uuids.port_id}='
|
|
f'NET_BW_EGR_KILOBIT_PER_SEC%3A1000%2C'
|
|
f'NET_BW_IGR_KILOBIT_PER_SEC%3A1000',
|
|
rr.to_querystring())
|
|
|
|
def test_resource_request_add_group_inserts_the_group(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0)
|
|
rs = objects.RequestSpec(flavor=flavor, is_bfv=False)
|
|
req = utils.ResourceRequest.from_request_spec(rs)
|
|
rg1 = objects.RequestGroup(requester_id='foo',
|
|
required_traits={'CUSTOM_FOO'})
|
|
req._add_request_group(rg1)
|
|
rg2 = objects.RequestGroup(requester_id='bar',
|
|
forbidden_traits={'CUSTOM_BAR'})
|
|
req._add_request_group(rg2)
|
|
self.assertIs(rg1, req.get_request_group('foo'))
|
|
self.assertIs(rg2, req.get_request_group('bar'))
|
|
|
|
def test_empty_groups_forbidden(self):
|
|
"""Not allowed to add premade RequestGroup without resources/traits/
|
|
aggregates.
|
|
"""
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0)
|
|
rs = objects.RequestSpec(flavor=flavor, is_bfv=False)
|
|
req = utils.ResourceRequest.from_request_spec(rs)
|
|
rg = objects.RequestGroup(requester_id='foo')
|
|
self.assertRaises(ValueError, req._add_request_group, rg)
|
|
|
|
def test_claim_resources_on_destination_no_source_allocations(self):
|
|
"""Tests the negative scenario where the instance does not have
|
|
allocations in Placement on the source compute node so no claim is
|
|
attempted on the destination compute node.
|
|
"""
|
|
reportclient = report.SchedulerReportClient()
|
|
instance = fake_instance.fake_instance_obj(self.context)
|
|
source_node = objects.ComputeNode(
|
|
uuid=uuids.source_node, host=instance.host)
|
|
dest_node = objects.ComputeNode(uuid=uuids.dest_node, host='dest-host')
|
|
|
|
@mock.patch.object(reportclient,
|
|
'get_allocs_for_consumer',
|
|
return_value={})
|
|
@mock.patch.object(reportclient,
|
|
'claim_resources',
|
|
new_callable=mock.NonCallableMock)
|
|
def test(mock_claim, mock_get_allocs):
|
|
ex = self.assertRaises(
|
|
exception.ConsumerAllocationRetrievalFailed,
|
|
utils.claim_resources_on_destination,
|
|
self.context, reportclient, instance, source_node, dest_node)
|
|
mock_get_allocs.assert_called_once_with(
|
|
self.context, instance.uuid)
|
|
self.assertIn(
|
|
'Expected to find allocations for source node resource '
|
|
'provider %s' % source_node.uuid, str(ex))
|
|
|
|
test()
|
|
|
|
def test_claim_resources_on_destination_claim_fails(self):
|
|
"""Tests the negative scenario where the resource allocation claim
|
|
on the destination compute node fails, resulting in an error.
|
|
"""
|
|
reportclient = report.SchedulerReportClient()
|
|
instance = fake_instance.fake_instance_obj(self.context)
|
|
source_node = objects.ComputeNode(
|
|
uuid=uuids.source_node, host=instance.host)
|
|
dest_node = objects.ComputeNode(uuid=uuids.dest_node, host='dest-host')
|
|
source_res_allocs = {
|
|
'allocations': {
|
|
uuids.source_node: {
|
|
'resources': {
|
|
'VCPU': instance.vcpus,
|
|
'MEMORY_MB': instance.memory_mb,
|
|
# This would really include ephemeral and swap too but
|
|
# we're lazy.
|
|
'DISK_GB': instance.root_gb
|
|
}
|
|
}
|
|
},
|
|
'consumer_generation': 1,
|
|
'project_id': uuids.project_id,
|
|
'user_id': uuids.user_id
|
|
}
|
|
dest_alloc_request = {
|
|
'allocations': {
|
|
uuids.dest_node: {
|
|
'resources': {
|
|
'VCPU': instance.vcpus,
|
|
'MEMORY_MB': instance.memory_mb,
|
|
'DISK_GB': instance.root_gb
|
|
}
|
|
}
|
|
},
|
|
}
|
|
|
|
@mock.patch.object(reportclient,
|
|
'get_allocs_for_consumer',
|
|
return_value=source_res_allocs)
|
|
@mock.patch.object(reportclient,
|
|
'claim_resources', return_value=False)
|
|
def test(mock_claim, mock_get_allocs):
|
|
# NOTE(danms): Don't pass source_node_allocations here to test
|
|
# that they are fetched if needed.
|
|
self.assertRaises(exception.NoValidHost,
|
|
utils.claim_resources_on_destination,
|
|
self.context, reportclient, instance,
|
|
source_node, dest_node)
|
|
mock_get_allocs.assert_called_once_with(
|
|
self.context, instance.uuid)
|
|
mock_claim.assert_called_once_with(
|
|
self.context, instance.uuid, dest_alloc_request,
|
|
instance.project_id, instance.user_id,
|
|
allocation_request_version='1.28', consumer_generation=1)
|
|
|
|
test()
|
|
|
|
def test_claim_resources_on_destination(self):
|
|
"""Happy path test where everything is successful."""
|
|
reportclient = report.SchedulerReportClient()
|
|
instance = fake_instance.fake_instance_obj(self.context)
|
|
source_node = objects.ComputeNode(
|
|
uuid=uuids.source_node, host=instance.host)
|
|
dest_node = objects.ComputeNode(uuid=uuids.dest_node, host='dest-host')
|
|
source_res_allocs = {
|
|
uuids.source_node: {
|
|
'resources': {
|
|
'VCPU': instance.vcpus,
|
|
'MEMORY_MB': instance.memory_mb,
|
|
# This would really include ephemeral and swap too but
|
|
# we're lazy.
|
|
'DISK_GB': instance.root_gb
|
|
}
|
|
}
|
|
}
|
|
dest_alloc_request = {
|
|
'allocations': {
|
|
uuids.dest_node: {
|
|
'resources': {
|
|
'VCPU': instance.vcpus,
|
|
'MEMORY_MB': instance.memory_mb,
|
|
'DISK_GB': instance.root_gb
|
|
}
|
|
}
|
|
},
|
|
}
|
|
|
|
@mock.patch.object(reportclient,
|
|
'get_allocs_for_consumer')
|
|
@mock.patch.object(reportclient,
|
|
'claim_resources', return_value=True)
|
|
def test(mock_claim, mock_get_allocs):
|
|
utils.claim_resources_on_destination(
|
|
self.context, reportclient, instance, source_node, dest_node,
|
|
source_res_allocs, consumer_generation=None)
|
|
self.assertFalse(mock_get_allocs.called)
|
|
mock_claim.assert_called_once_with(
|
|
self.context, instance.uuid, dest_alloc_request,
|
|
instance.project_id, instance.user_id,
|
|
allocation_request_version='1.28', consumer_generation=None)
|
|
|
|
test()
|
|
|
|
@mock.patch('nova.scheduler.client.report.SchedulerReportClient')
|
|
@mock.patch('nova.scheduler.utils.request_is_rebuild')
|
|
def test_claim_resources(self, mock_is_rebuild, mock_client):
|
|
"""Tests that when claim_resources() is called, that we appropriately
|
|
call the placement client to claim resources for the instance.
|
|
"""
|
|
mock_is_rebuild.return_value = False
|
|
ctx = nova_context.RequestContext(user_id=uuids.user_id)
|
|
spec_obj = objects.RequestSpec(project_id=uuids.project_id)
|
|
instance_uuid = uuids.instance
|
|
alloc_req = mock.sentinel.alloc_req
|
|
mock_client.claim_resources.return_value = True
|
|
|
|
res = utils.claim_resources(ctx, mock_client, spec_obj, instance_uuid,
|
|
alloc_req)
|
|
|
|
mock_client.claim_resources.assert_called_once_with(
|
|
ctx, uuids.instance, mock.sentinel.alloc_req, uuids.project_id,
|
|
uuids.user_id, allocation_request_version=None,
|
|
consumer_generation=None)
|
|
self.assertTrue(res)
|
|
|
|
# Now do it again but with RequestSpec.user_id set.
|
|
spec_obj.user_id = uuids.spec_user_id
|
|
mock_client.reset_mock()
|
|
utils.claim_resources(ctx, mock_client, spec_obj, instance_uuid,
|
|
alloc_req)
|
|
mock_client.claim_resources.assert_called_once_with(
|
|
ctx, uuids.instance, mock.sentinel.alloc_req, uuids.project_id,
|
|
uuids.spec_user_id, allocation_request_version=None,
|
|
consumer_generation=None)
|
|
|
|
@mock.patch('nova.scheduler.client.report.SchedulerReportClient')
|
|
@mock.patch('nova.scheduler.utils.request_is_rebuild')
|
|
def test_claim_resources_for_policy_check(self, mock_is_rebuild,
|
|
mock_client):
|
|
mock_is_rebuild.return_value = True
|
|
ctx = mock.Mock(user_id=uuids.user_id)
|
|
res = utils.claim_resources(ctx, None, mock.sentinel.spec_obj,
|
|
mock.sentinel.instance_uuid, [])
|
|
self.assertTrue(res)
|
|
mock_is_rebuild.assert_called_once_with(mock.sentinel.spec_obj)
|
|
self.assertFalse(mock_client.claim_resources.called)
|
|
|
|
def test_get_weight_multiplier(self):
|
|
host_attr = {'vcpus_total': 4, 'vcpus_used': 6,
|
|
'cpu_allocation_ratio': 1.0}
|
|
host1 = fakes.FakeHostState('fake-host', 'node', host_attr)
|
|
|
|
host1.aggregates = [
|
|
objects.Aggregate(
|
|
id=1,
|
|
name='foo',
|
|
hosts=['fake-host'],
|
|
metadata={'cpu_weight_multiplier': 'invalid'},
|
|
)]
|
|
# Get value from default given value if the agg meta is invalid.
|
|
self.assertEqual(
|
|
1.0,
|
|
utils.get_weight_multiplier(host1, 'cpu_weight_multiplier', 1.0)
|
|
)
|
|
|
|
host1.aggregates = [
|
|
objects.Aggregate(
|
|
id=1,
|
|
name='foo',
|
|
hosts=['fake-host'],
|
|
metadata={'cpu_weight_multiplier': '1.9'},
|
|
)]
|
|
# Get value from aggregate metadata
|
|
self.assertEqual(
|
|
1.9,
|
|
utils.get_weight_multiplier(host1, 'cpu_weight_multiplier', 1.0)
|
|
)
|
|
|
|
host1.aggregates = [
|
|
objects.Aggregate(
|
|
id=1,
|
|
name='foo',
|
|
hosts=['fake-host'],
|
|
metadata={'cpu_weight_multiplier': '1.9'}),
|
|
objects.Aggregate(
|
|
id=2,
|
|
name='foo',
|
|
hosts=['fake-host'],
|
|
metadata={'cpu_weight_multiplier': '1.8'}),
|
|
]
|
|
# Get min value from aggregate metadata
|
|
self.assertEqual(
|
|
1.8,
|
|
utils.get_weight_multiplier(host1, 'cpu_weight_multiplier', 1.0)
|
|
)
|
|
|
|
def _set_up_and_fill_provider_mapping(self, requested_resources):
|
|
request_spec = objects.RequestSpec()
|
|
request_spec.requested_resources = requested_resources
|
|
allocs = {
|
|
uuids.rp_uuid1: {
|
|
'resources': {
|
|
'NET_BW_EGR_KILOBIT_PER_SEC': 1,
|
|
}
|
|
},
|
|
uuids.rp_uuid2: {
|
|
'resources': {
|
|
'NET_BW_INGR_KILOBIT_PER_SEC': 1,
|
|
}
|
|
}
|
|
}
|
|
mappings = {
|
|
uuids.port_id1: [uuids.rp_uuid2],
|
|
uuids.port_id2: [uuids.rp_uuid1],
|
|
}
|
|
allocation_req = {'allocations': allocs, 'mappings': mappings}
|
|
selection = objects.Selection(
|
|
allocation_request=jsonutils.dumps(allocation_req))
|
|
|
|
# Unmapped initially
|
|
for rg in requested_resources:
|
|
self.assertEqual([], rg.provider_uuids)
|
|
|
|
utils.fill_provider_mapping(request_spec, selection)
|
|
|
|
def test_fill_provider_mapping(self):
|
|
rg1 = objects.RequestGroup(requester_id=uuids.port_id1)
|
|
rg2 = objects.RequestGroup(requester_id=uuids.port_id2)
|
|
self._set_up_and_fill_provider_mapping([rg1, rg2])
|
|
|
|
# Validate the mappings
|
|
self.assertEqual([uuids.rp_uuid2], rg1.provider_uuids)
|
|
self.assertEqual([uuids.rp_uuid1], rg2.provider_uuids)
|
|
|
|
def test_fill_provider_mapping_no_op(self):
|
|
# This just proves that having 'mappings' in the allocation request
|
|
# doesn't break anything.
|
|
self._set_up_and_fill_provider_mapping([])
|
|
|
|
@mock.patch.object(objects.RequestSpec,
|
|
'map_requested_resources_to_providers')
|
|
def test_fill_provider_mapping_based_on_allocation_returns_early(
|
|
self, mock_map):
|
|
context = nova_context.RequestContext()
|
|
request_spec = objects.RequestSpec()
|
|
# set up the request that there is nothing to do
|
|
request_spec.requested_resources = []
|
|
report_client = mock.sentinel.report_client
|
|
allocation = mock.sentinel.allocation
|
|
|
|
utils.fill_provider_mapping_based_on_allocation(
|
|
context, report_client, request_spec, allocation)
|
|
|
|
mock_map.assert_not_called()
|
|
|
|
@mock.patch('nova.scheduler.client.report.SchedulerReportClient')
|
|
@mock.patch.object(objects.RequestSpec,
|
|
'map_requested_resources_to_providers')
|
|
def test_fill_provider_mapping_based_on_allocation(
|
|
self, mock_map, mock_report_client):
|
|
context = nova_context.RequestContext()
|
|
request_spec = objects.RequestSpec()
|
|
# set up the request that there is nothing to do
|
|
request_spec.requested_resources = [objects.RequestGroup()]
|
|
allocation = {
|
|
uuids.rp_uuid: {
|
|
'resources': {
|
|
'NET_BW_EGR_KILOBIT_PER_SEC': 1,
|
|
}
|
|
}
|
|
}
|
|
traits = ['CUSTOM_PHYSNET1', 'CUSTOM_VNIC_TYPE_NORMAL']
|
|
mock_report_client.get_provider_traits.return_value = report.TraitInfo(
|
|
traits=['CUSTOM_PHYSNET1', 'CUSTOM_VNIC_TYPE_NORMAL'],
|
|
generation=0)
|
|
|
|
utils.fill_provider_mapping_based_on_allocation(
|
|
context, mock_report_client, request_spec, allocation)
|
|
|
|
mock_map.assert_called_once_with(allocation, {uuids.rp_uuid: traits})
|
|
|
|
|
|
class TestEncryptedMemoryTranslation(TestUtilsBase):
|
|
flavor_name = 'm1.test'
|
|
image_name = 'cirros'
|
|
|
|
def _get_request_spec(self, extra_specs, image):
|
|
flavor = objects.Flavor(name=self.flavor_name,
|
|
vcpus=1,
|
|
memory_mb=1024,
|
|
root_gb=10,
|
|
ephemeral_gb=5,
|
|
swap=0,
|
|
extra_specs=extra_specs)
|
|
|
|
# NOTE(aspiers): RequestSpec.flavor is not nullable, but
|
|
# RequestSpec.image is.
|
|
reqspec = objects.RequestSpec(flavor=flavor)
|
|
|
|
if image:
|
|
reqspec.image = image
|
|
|
|
return reqspec
|
|
|
|
def _get_resource_request(self, extra_specs, image):
|
|
reqspec = self._get_request_spec(extra_specs, image)
|
|
return utils.ResourceRequest.from_request_spec(reqspec)
|
|
|
|
def _get_expected_resource_request(self, mem_encryption_context):
|
|
expected_resources = {
|
|
'VCPU': 1,
|
|
'MEMORY_MB': 1024,
|
|
'DISK_GB': 15,
|
|
}
|
|
if mem_encryption_context:
|
|
expected_resources[orc.MEM_ENCRYPTION_CONTEXT] = 1
|
|
|
|
expected = FakeResourceRequest()
|
|
expected._rg_by_id[None] = objects.RequestGroup(
|
|
use_same_provider=False,
|
|
resources=expected_resources)
|
|
return expected
|
|
|
|
def _test_encrypted_memory_support_not_required(self, extra_specs,
|
|
image=None):
|
|
resreq = self._get_resource_request(extra_specs, image)
|
|
expected = self._get_expected_resource_request(False)
|
|
|
|
self.assertResourceRequestsEqual(expected, resreq)
|
|
|
|
def test_encrypted_memory_support_empty_extra_specs(self):
|
|
self._test_encrypted_memory_support_not_required(extra_specs={})
|
|
|
|
def test_encrypted_memory_support_false_extra_spec(self):
|
|
for extra_spec in ('0', 'false', 'False'):
|
|
self._test_encrypted_memory_support_not_required(
|
|
extra_specs={'hw:mem_encryption': extra_spec})
|
|
|
|
def test_encrypted_memory_support_empty_image_props(self):
|
|
self._test_encrypted_memory_support_not_required(
|
|
extra_specs={},
|
|
image=objects.ImageMeta(properties=objects.ImageMetaProps()))
|
|
|
|
def test_encrypted_memory_support_false_image_prop(self):
|
|
for image_prop in ('0', 'false', 'False'):
|
|
self._test_encrypted_memory_support_not_required(
|
|
extra_specs={},
|
|
image=objects.ImageMeta(
|
|
properties=objects.ImageMetaProps(
|
|
hw_mem_encryption=image_prop))
|
|
)
|
|
|
|
def test_encrypted_memory_support_both_false(self):
|
|
for extra_spec in ('0', 'false', 'False'):
|
|
for image_prop in ('0', 'false', 'False'):
|
|
self._test_encrypted_memory_support_not_required(
|
|
extra_specs={'hw:mem_encryption': extra_spec},
|
|
image=objects.ImageMeta(
|
|
properties=objects.ImageMetaProps(
|
|
hw_mem_encryption=image_prop))
|
|
)
|
|
|
|
def _test_encrypted_memory_support_conflict(self, extra_spec,
|
|
image_prop_in,
|
|
image_prop_out):
|
|
# NOTE(aspiers): hw_mem_encryption image property is a
|
|
# FlexibleBooleanField, so the result should always be coerced
|
|
# to a boolean.
|
|
self.assertIsInstance(image_prop_out, bool)
|
|
|
|
image = objects.ImageMeta(
|
|
name=self.image_name,
|
|
properties=objects.ImageMetaProps(
|
|
hw_mem_encryption=image_prop_in)
|
|
)
|
|
|
|
reqspec = self._get_request_spec(
|
|
extra_specs={'hw:mem_encryption': extra_spec},
|
|
image=image)
|
|
|
|
# Sanity check that our test request spec has an extra_specs
|
|
# dict, which is needed in order for there to be a conflict.
|
|
self.assertIn('flavor', reqspec)
|
|
self.assertIn('extra_specs', reqspec.flavor)
|
|
|
|
error = (
|
|
"Flavor %(flavor_name)s has hw:mem_encryption extra spec "
|
|
"explicitly set to %(flavor_val)s, conflicting with "
|
|
"image %(image_name)s which has hw_mem_encryption property "
|
|
"explicitly set to %(image_val)s"
|
|
)
|
|
exc = self.assertRaises(
|
|
exception.FlavorImageConflict,
|
|
utils.ResourceRequest.from_request_spec, reqspec
|
|
)
|
|
error_data = {
|
|
'flavor_name': self.flavor_name,
|
|
'flavor_val': extra_spec,
|
|
'image_name': self.image_name,
|
|
'image_val': image_prop_out,
|
|
}
|
|
self.assertEqual(error % error_data, str(exc))
|
|
|
|
def test_encrypted_memory_support_conflict1(self):
|
|
for extra_spec in ('0', 'false', 'False'):
|
|
for image_prop_in in ('1', 'true', 'True'):
|
|
self._test_encrypted_memory_support_conflict(
|
|
extra_spec, image_prop_in, True
|
|
)
|
|
|
|
def test_encrypted_memory_support_conflict2(self):
|
|
for extra_spec in ('1', 'true', 'True'):
|
|
for image_prop_in in ('0', 'false', 'False'):
|
|
self._test_encrypted_memory_support_conflict(
|
|
extra_spec, image_prop_in, False
|
|
)
|
|
|
|
@mock.patch.object(utils, 'LOG')
|
|
def _test_encrypted_memory_support_required(self, requesters, extra_specs,
|
|
mock_log, image=None):
|
|
resreq = self._get_resource_request(extra_specs, image)
|
|
expected = self._get_expected_resource_request(True)
|
|
|
|
self.assertResourceRequestsEqual(expected, resreq)
|
|
mock_log.debug.assert_has_calls([
|
|
mock.call('Added %s=1 to requested resources',
|
|
orc.MEM_ENCRYPTION_CONTEXT)
|
|
])
|
|
|
|
def test_encrypted_memory_support_extra_spec(self):
|
|
for extra_spec in ('1', 'true', 'True'):
|
|
self._test_encrypted_memory_support_required(
|
|
'hw:mem_encryption extra spec',
|
|
{'hw:mem_encryption': extra_spec},
|
|
image=objects.ImageMeta(
|
|
id='005249be-3c2f-4351-9df7-29bb13c21b14',
|
|
properties=objects.ImageMetaProps(
|
|
hw_machine_type='q35',
|
|
hw_firmware_type='uefi'))
|
|
)
|
|
|
|
def test_encrypted_memory_support_image_prop(self):
|
|
for image_prop in ('1', 'true', 'True'):
|
|
self._test_encrypted_memory_support_required(
|
|
'hw_mem_encryption image property',
|
|
{},
|
|
image=objects.ImageMeta(
|
|
id='005249be-3c2f-4351-9df7-29bb13c21b14',
|
|
name=self.image_name,
|
|
properties=objects.ImageMetaProps(
|
|
hw_machine_type='q35',
|
|
hw_firmware_type='uefi',
|
|
hw_mem_encryption=image_prop))
|
|
)
|
|
|
|
def test_encrypted_memory_support_both_required(self):
|
|
for extra_spec in ('1', 'true', 'True'):
|
|
for image_prop in ('1', 'true', 'True'):
|
|
self._test_encrypted_memory_support_required(
|
|
'hw:mem_encryption extra spec and '
|
|
'hw_mem_encryption image property',
|
|
{'hw:mem_encryption': extra_spec},
|
|
image=objects.ImageMeta(
|
|
id='005249be-3c2f-4351-9df7-29bb13c21b14',
|
|
name=self.image_name,
|
|
properties=objects.ImageMetaProps(
|
|
hw_machine_type='q35',
|
|
hw_firmware_type='uefi',
|
|
hw_mem_encryption=image_prop))
|
|
)
|
|
|
|
|
|
class TestResourcesFromRequestGroupDefaultPolicy(test.NoDBTestCase):
|
|
"""These test cases assert what happens when the group policy is missing
|
|
from the flavor but more than one numbered request group is requested from
|
|
various sources. Note that while image can provide required traits for the
|
|
resource request those traits are always added to the unnumbered group so
|
|
image cannot be a source of additional numbered groups.
|
|
"""
|
|
|
|
def setUp(self):
|
|
super(TestResourcesFromRequestGroupDefaultPolicy, self).setUp()
|
|
self.context = nova_context.get_admin_context()
|
|
self.port_group1 = objects.RequestGroup.from_port_request(
|
|
self.context, uuids.port1,
|
|
port_resource_request={
|
|
"resources": {
|
|
"NET_BW_IGR_KILOBIT_PER_SEC": 1000,
|
|
"NET_BW_EGR_KILOBIT_PER_SEC": 1000},
|
|
"required": ["CUSTOM_PHYSNET_2",
|
|
"CUSTOM_VNIC_TYPE_NORMAL"]
|
|
})
|
|
self.port_group2 = objects.RequestGroup.from_port_request(
|
|
self.context, uuids.port2,
|
|
port_resource_request={
|
|
"resources": {
|
|
"NET_BW_IGR_KILOBIT_PER_SEC": 2000,
|
|
"NET_BW_EGR_KILOBIT_PER_SEC": 2000},
|
|
"required": ["CUSTOM_PHYSNET_3",
|
|
"CUSTOM_VNIC_TYPE_DIRECT"]
|
|
})
|
|
self.image = objects.ImageMeta(properties=objects.ImageMetaProps())
|
|
|
|
def test_one_group_from_flavor_dont_warn(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs={
|
|
'resources1:CUSTOM_BAR': '2',
|
|
})
|
|
request_spec = objects.RequestSpec(
|
|
flavor=flavor, image=self.image, requested_resources=[])
|
|
|
|
rr = utils.resources_from_request_spec(
|
|
self.context, request_spec, host_manager=mock.Mock())
|
|
|
|
log = self.stdlog.logger.output
|
|
self.assertNotIn(
|
|
"There is more than one numbered request group in the allocation "
|
|
"candidate query but the flavor did not specify any group policy.",
|
|
log)
|
|
self.assertNotIn(
|
|
"To avoid the placement failure nova defaults the group policy to "
|
|
"'none'.",
|
|
log)
|
|
self.assertIsNone(rr.group_policy)
|
|
self.assertNotIn('group_policy=none', rr.to_querystring())
|
|
|
|
def test_one_group_from_port_dont_warn(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs={})
|
|
request_spec = objects.RequestSpec(
|
|
flavor=flavor, image=self.image,
|
|
requested_resources=[self.port_group1])
|
|
|
|
rr = utils.resources_from_request_spec(
|
|
self.context, request_spec, host_manager=mock.Mock())
|
|
|
|
log = self.stdlog.logger.output
|
|
self.assertNotIn(
|
|
"There is more than one numbered request group in the allocation "
|
|
"candidate query but the flavor did not specify any group policy.",
|
|
log)
|
|
self.assertNotIn(
|
|
"To avoid the placement failure nova defaults the group policy to "
|
|
"'none'.",
|
|
log)
|
|
self.assertIsNone(rr.group_policy)
|
|
self.assertNotIn('group_policy=none', rr.to_querystring())
|
|
|
|
def test_two_groups_from_flavor_only_warns(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs={
|
|
'resources1:CUSTOM_BAR': '2',
|
|
'resources2:CUSTOM_FOO': '1'
|
|
})
|
|
request_spec = objects.RequestSpec(
|
|
flavor=flavor, image=self.image, requested_resources=[])
|
|
|
|
rr = utils.resources_from_request_spec(
|
|
self.context, request_spec, host_manager=mock.Mock())
|
|
|
|
log = self.stdlog.logger.output
|
|
self.assertIn(
|
|
"There is more than one numbered request group in the allocation "
|
|
"candidate query but the flavor did not specify any group policy.",
|
|
log)
|
|
self.assertNotIn(
|
|
"To avoid the placement failure nova defaults the group policy to "
|
|
"'none'.",
|
|
log)
|
|
self.assertIsNone(rr.group_policy)
|
|
self.assertNotIn('group_policy', rr.to_querystring())
|
|
|
|
def test_one_group_from_flavor_one_from_port_policy_defaulted(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs={
|
|
'resources1:CUSTOM_BAR': '2',
|
|
})
|
|
request_spec = objects.RequestSpec(
|
|
flavor=flavor, image=self.image,
|
|
requested_resources=[self.port_group1])
|
|
|
|
rr = utils.resources_from_request_spec(
|
|
self.context, request_spec, host_manager=mock.Mock())
|
|
|
|
log = self.stdlog.logger.output
|
|
self.assertIn(
|
|
"There is more than one numbered request group in the allocation "
|
|
"candidate query but the flavor did not specify any group policy.",
|
|
log)
|
|
self.assertIn(
|
|
"To avoid the placement failure nova defaults the group policy to "
|
|
"'none'.",
|
|
log)
|
|
self.assertEqual('none', rr.group_policy)
|
|
self.assertIn('group_policy=none', rr.to_querystring())
|
|
|
|
def test_two_groups_from_ports_policy_defaulted(self):
|
|
flavor = objects.Flavor(
|
|
vcpus=1, memory_mb=1024, root_gb=10, ephemeral_gb=5, swap=0,
|
|
extra_specs={})
|
|
request_spec = objects.RequestSpec(
|
|
flavor=flavor, image=self.image,
|
|
requested_resources=[self.port_group1, self.port_group2])
|
|
|
|
rr = utils.resources_from_request_spec(
|
|
self.context, request_spec, host_manager=mock.Mock())
|
|
|
|
log = self.stdlog.logger.output
|
|
self.assertIn(
|
|
"There is more than one numbered request group in the allocation "
|
|
"candidate query but the flavor did not specify any group policy.",
|
|
log)
|
|
self.assertIn(
|
|
"To avoid the placement failure nova defaults the group policy to "
|
|
"'none'.",
|
|
log)
|
|
self.assertEqual('none', rr.group_policy)
|
|
self.assertIn('group_policy=none', rr.to_querystring())
|