from neutron.agent.l2.extensions import qos
from neutron.api.rpc.callbacks.consumer import registry
from neutron.api.rpc.callbacks import events
from neutron.api.rpc.callbacks import resources
from neutron.api.rpc.handlers import resources_rpc
from neutron.common import exceptions
from neutron import context
from neutron.objects.qos import policy
from neutron.objects.qos import rule
from neutron.plugins.ml2.drivers.openvswitch.agent.common import constants
from neutron.services.qos import qos_consts
from neutron.tests import base
BASE_TEST_POLICY = {'context': None, 'name': 'test1', 'id': 'fake_policy_id'}
TEST_POLICY = policy.QosPolicy(**BASE_TEST_POLICY)
TEST_POLICY_DESCR = policy.QosPolicy(description='fake_descr',
**BASE_TEST_POLICY)
TEST_POLICY2 = policy.QosPolicy(context=None,
name='test2',
id='fake_policy_id_2')
TEST_PORT = {'port_id': 'test_port_id', 'qos_policy_id': TEST_POLICY.id}
TEST_PORT2 = {'port_id': 'test_port_id_2', 'qos_policy_id': TEST_POLICY2.id}
class FakeDriver(qos.QosAgentDriver):
def setUp(self):
super(TestQosPlugin, self).setUp()
self.setup_coreplugin(load_plugins=False)
mock.patch('neutron.objects.db.api.create_object').start()
mock.patch('neutron.objects.db.api.update_object').start()
mock.patch('neutron.objects.db.api.delete_object').start()
mock.patch('neutron.objects.db.api.get_object').start()
_mock_qos_load_attr = mock.patch(
'neutron.objects.qos.policy.QosPolicy.obj_load_attr')
self.mock_qos_load_attr = _mock_qos_load_attr.start()
# We don't use real models as per mocks above. We also need to mock-out
# methods that work with real data types
mock.patch('neutron.objects.base.NeutronDbObject.modify_fields_from_db'
).start()
mock.patch.object(policy_object.QosPolicy, 'unset_default').start()
mock.patch.object(policy_object.QosPolicy, 'set_default').start()
cfg.CONF.set_override("core_plugin", DB_PLUGIN_KLASS)
cfg.CONF.set_override("service_plugins", ["qos"])
manager.init()
self.qos_plugin = directory.get_plugin(plugins_constants.QOS)
self.qos_plugin.driver_manager = mock.Mock()
self.rpc_push = mock.patch('neutron.api.rpc.handlers.resources_rpc'
'.ResourcesPushRpcApi.push').start()
self.ctxt = context.Context('fake_user', 'fake_tenant')
mock.patch.object(self.ctxt.session, 'refresh').start()
mock.patch.object(self.ctxt.session, 'expunge').start()
self.policy_data = {
'policy': {
'id': uuidutils.generate_uuid(),
'project_id': uuidutils.generate_uuid(),
'name': 'test-policy',
'description': 'Test policy description',
'shared': True,
'is_default': False
}
}
self.rule_data = {
'bandwidth_limit_rule': {
'id': uuidutils.generate_uuid(),
'max_kbps': 100,
'max_burst_kbps': 150
},
'dscp_marking_rule': {
'id': uuidutils.generate_uuid(),
'dscp_mark': 16
},
'minimum_bandwidth_rule': {
'id': uuidutils.generate_uuid(),
'min_kbps': 10
}
}
self.policy = policy_object.QosPolicy(self.ctxt,
**self.policy_data['policy'])
self.rule = rule_object.QosBandwidthLimitRule(
self.ctxt, **self.rule_data['bandwidth_limit_rule'])
self.dscp_rule = rule_object.QosDscpMarkingRule(
self.ctxt, **self.rule_data['dscp_marking_rule'])
self.min_rule = rule_object.QosMinimumBandwidthRule(
self.ctxt, **self.rule_data['minimum_bandwidth_rule'])
def setUp(self):
# Reset the drive to re-create it
qos_driver.DRIVER = None
super(TestQosNsxV3Notification, self).setUp()
self.setup_coreplugin(PLUGIN_NAME)
self.qos_plugin = qos_plugin.QoSPlugin()
self.ctxt = context.Context('fake_user', 'fake_tenant')
mock.patch.object(self.ctxt.session, 'refresh').start()
mock.patch.object(self.ctxt.session, 'expunge').start()
self.policy_data = {
'policy': {
'id': uuidutils.generate_uuid(),
'project_id': uuidutils.generate_uuid(),
'name': 'test-policy',
'description': 'Test policy description',
'shared': True
}
}
self.rule_data = {
'bandwidth_limit_rule': {
'id': uuidutils.generate_uuid(),
'max_kbps': 2000,
'max_burst_kbps': 150
}
}
self.ingress_rule_data = {
'bandwidth_limit_rule': {
'id': uuidutils.generate_uuid(),
'max_kbps': 3000,
'max_burst_kbps': 350,
'direction': 'ingress'
}
}
self.dscp_rule_data = {
'dscp_marking_rule': {
'id': uuidutils.generate_uuid(),
'dscp_mark': 22
}
}
self.policy = policy_object.QosPolicy(self.ctxt,
**self.policy_data['policy'])
# egress BW limit rule
self.rule = rule_object.QosBandwidthLimitRule(
self.ctxt, **self.rule_data['bandwidth_limit_rule'])
# ingress bw limit rule
self.ingress_rule = rule_object.QosBandwidthLimitRule(
self.ctxt, **self.ingress_rule_data['bandwidth_limit_rule'])
self.dscp_rule = rule_object.QosDscpMarkingRule(
self.ctxt, **self.dscp_rule_data['dscp_marking_rule'])
self.fake_profile_id = 'fake_profile'
self.fake_profile = {'id': self.fake_profile_id}
mock.patch('neutron.objects.db.api.create_object').start()
mock.patch('neutron.objects.db.api.update_object').start()
mock.patch('neutron.objects.db.api.delete_object').start()
mock.patch.object(nsx_db,
'get_switch_profile_by_qos_policy',
return_value=self.fake_profile_id).start()
self.peak_bw_multiplier = cfg.CONF.NSX.qos_peak_bw_multiplier
self.nsxlib = v3_utils.get_nsxlib_wrapper()
def setUp(self, *mocks):
# init the nsx-v plugin for testing with DVS
self._init_dvs_config()
super(TestQosNsxVNotification, self).setUp(plugin=CORE_PLUGIN,
ext_mgr=None)
plugin_instance = manager.NeutronManager.get_plugin()
self._core_plugin = plugin_instance
# Setup the QoS plugin:
# Add a dummy notification driver that calls our handler directly
# (to skip the message queue)
cfg.CONF.set_override("notification_drivers", [
'vmware_nsx.tests.unit.services.qos.fake_nsxv_notifier.'
'DummyNsxVNotificationDriver'
], "qos")
self.qos_plugin = qos_plugin.QoSPlugin()
mock.patch.object(qos_utils.NsxVQosRule,
'_get_qos_plugin',
return_value=self.qos_plugin).start()
# Pre defined QoS data for the tests
self.ctxt = context.Context('fake_user', 'fake_tenant')
self.policy_data = {
'policy': {
'id': uuidutils.generate_uuid(),
'tenant_id': uuidutils.generate_uuid(),
'name': 'test-policy',
'description': 'Test policy description',
'shared': True
}
}
self.rule_data = {
'bandwidth_limit_rule': {
'id': uuidutils.generate_uuid(),
'max_kbps': 100,
'max_burst_kbps': 150
}
}
self.dscp_rule_data = {
'dscp_marking_rule': {
'id': uuidutils.generate_uuid(),
'dscp_mark': 22
}
}
self.policy = policy_object.QosPolicy(self.ctxt,
**self.policy_data['policy'])
self.rule = rule_object.QosBandwidthLimitRule(
self.ctxt, **self.rule_data['bandwidth_limit_rule'])
self.dscp_rule = rule_object.QosDscpMarkingRule(
self.ctxt, **self.dscp_rule_data['dscp_marking_rule'])
self._net_data = {
'network': {
'name': 'test-qos',
'tenant_id': 'fake_tenant',
'qos_policy_id': self.policy.id,
'port_security_enabled': False,
'admin_state_up': False,
'shared': False
}
}
self._rules = [self.rule_data['bandwidth_limit_rule']]
self._dscp_rules = [self.dscp_rule_data['dscp_marking_rule']]
mock.patch('neutron.objects.db.api.create_object').start()
mock.patch('neutron.objects.db.api.update_object').start()
mock.patch('neutron.objects.db.api.delete_object').start()
mock.patch('neutron.objects.db.api.get_object').start()
mock.patch(
'neutron.objects.qos.policy.QosPolicy.obj_load_attr').start()
def _create_fake_policy(self):
policy_dict = {'id': self.network_policy_id}
policy_obj = qos_policy.QosPolicy(context, **policy_dict)
policy_obj.obj_reset_changes()
return policy_obj
def _make_qos_policy(self):
qos_policy = policy_object.QosPolicy(self.admin_ctxt,
**self.policy_data['policy'])
qos_policy.create()
return qos_policy
def test_detach_network_nonexistent_policy(self):
policy_obj = policy.QosPolicy(self.context, **self.db_objs[0])
self.assertRaises(n_exc.NetworkQosBindingNotFound,
policy_obj.detach_network, self._network['id'])
# 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.
from unittest import mock
from oslo_utils import uuidutils
from neutron.agent.l3.extensions.qos import base as qos_base
from neutron.objects.qos import policy
from neutron.tests import base
_uuid = uuidutils.generate_uuid
TEST_POLICY = policy.QosPolicy(context=None, name='test1', id=_uuid())
TEST_POLICY2 = policy.QosPolicy(context=None, name='test2', id=_uuid())
TEST_RES_1 = "res1"
TEST_RES_2 = "res2"
class RateLimitMapsTestCase(base.BaseTestCase):
def setUp(self):
super(RateLimitMapsTestCase, self).setUp()
self.policy_map = qos_base.RateLimitMaps("cache-lock")
def test_update_policy(self):
self.policy_map.update_policy(TEST_POLICY)
self.assertEqual(TEST_POLICY,
self.policy_map.known_policies[TEST_POLICY.id])
def _create_test_policy(self):
policy_obj = policy.QosPolicy(self.context, **self.db_obj)
policy_obj.create()
return policy_obj
def test_detach_port_nonexistent_policy(self):
policy_obj = policy.QosPolicy(self.context, **self.db_objs[0])
self.assertRaises(n_exc.PortQosBindingNotFound, policy_obj.detach_port,
self._port['id'])
def setUp(self, *mocks):
# init the nsx-v plugin for testing with DVS
self._init_dvs_config()
# Reset the drive to re-create it
qos_driver.DRIVER = None
super(TestQosNsxVNotification, self).setUp(plugin=CORE_PLUGIN,
ext_mgr=None)
self.setup_coreplugin(CORE_PLUGIN)
plugin_instance = directory.get_plugin()
self._core_plugin = plugin_instance
self._core_plugin.init_is_complete = True
self.qos_plugin = qos_plugin.QoSPlugin()
mock.patch.object(qos_utils.NsxVQosRule,
'_get_qos_plugin',
return_value=self.qos_plugin).start()
# Pre defined QoS data for the tests
self.ctxt = context.Context('fake_user', 'fake_tenant')
self.policy_data = {
'policy': {
'id': uuidutils.generate_uuid(),
'project_id': uuidutils.generate_uuid(),
'name': 'test-policy',
'description': 'Test policy description',
'shared': True
}
}
self.rule_data = {
'bandwidth_limit_rule': {
'id': uuidutils.generate_uuid(),
'max_kbps': 100,
'max_burst_kbps': 150,
'type': qos_consts.RULE_TYPE_BANDWIDTH_LIMIT
}
}
self.dscp_rule_data = {
'dscp_marking_rule': {
'id': uuidutils.generate_uuid(),
'dscp_mark': 22,
'type': qos_consts.RULE_TYPE_DSCP_MARKING
}
}
self.policy = policy_object.QosPolicy(self.ctxt,
**self.policy_data['policy'])
self.rule = rule_object.QosBandwidthLimitRule(
self.ctxt, **self.rule_data['bandwidth_limit_rule'])
self.dscp_rule = rule_object.QosDscpMarkingRule(
self.ctxt, **self.dscp_rule_data['dscp_marking_rule'])
self._net_data = {
'network': {
'name': 'test-qos',
'tenant_id': 'fake_tenant',
'qos_policy_id': self.policy.id,
'port_security_enabled': False,
'admin_state_up': False,
'shared': False
}
}
self._rules = [self.rule_data['bandwidth_limit_rule']]
self._dscp_rules = [self.dscp_rule_data['dscp_marking_rule']]
mock.patch(
'neutron.objects.qos.policy.QosPolicy.obj_load_attr').start()
def test_get_resource_type(self):
# we could use any other registered NeutronObject type here
self.assertEqual(policy.QosPolicy.obj_name(),
resources.get_resource_type(policy.QosPolicy()))
def setUp(self, *args, **kwargs):
net_type = kwargs.pop('tenant_network_types', None) or ['vlan']
ml2_options = {
'mechanism_drivers': ['apic_aim', 'openvswitch'],
'extension_drivers': ['apic_aim', 'port_security', 'dns', 'qos'],
'type_drivers': ['opflex', 'local', 'vlan'],
'tenant_network_types': net_type
}
config.cfg.CONF.set_override('network_vlan_ranges',
['physnet1:100:200'],
group='ml2_type_vlan')
self._aim_mech_driver = None
self._qos_driver = None
super(TestAIMQosBase, self).setUp(*args,
ml2_options=ml2_options,
qos_plugin='qos',
**kwargs)
self._plugin = directory.get_plugin()
self._plugin.remove_networks_from_down_agents = mock.Mock()
self._plugin.is_agent_down = mock.Mock(return_value=False)
self._ctx = context.get_admin_context()
self.ctxt = context.Context('fake_user', 'fake_tenant')
self.admin_ctxt = context.get_admin_context()
self.policy_data = {
'policy': {
'id': uuidutils.generate_uuid(),
'project_id': uuidutils.generate_uuid(),
'name': 'test-policy',
'description': 'Test policy description',
'shared': True,
'is_default': False
}
}
self.rule_data = {
'egress_bandwidth_limit_rule': {
'id': uuidutils.generate_uuid(),
'direction': 'egress',
'max_kbps': 100,
'max_burst_kbps': 150
},
'ingress_bandwidth_limit_rule': {
'id': uuidutils.generate_uuid(),
'direction': 'ingress',
'max_kbps': 101,
'max_burst_kbps': 1150
},
'dscp_marking_rule': {
'id': uuidutils.generate_uuid(),
'dscp_mark': 16
},
}
self.policy = policy_object.QosPolicy(self.ctxt,
**self.policy_data['policy'])
self.egress_rule = rule_object.QosBandwidthLimitRule(
self.ctxt, **self.rule_data['egress_bandwidth_limit_rule'])
self.ingress_rule = rule_object.QosBandwidthLimitRule(
self.ctxt, **self.rule_data['ingress_bandwidth_limit_rule'])
self.dscp_rule = rule_object.QosDscpMarkingRule(
self.ctxt, **self.rule_data['dscp_marking_rule'])
def _get_policy(self):
return policy_object.QosPolicy(self.ctxt, **self.policy_data['policy'])
def update_policy(self, context, policy_id, policy):
policy = policy_object.QosPolicy(context, **policy['policy'])
policy.id = policy_id
policy.update()
self.notification_driver_manager.update_policy(context, policy)
return policy
def setUp(self):
super(QosExtensionBaseTestCase, self).setUp()
self.gw_ip_qos_ext = gateway_ip_qos.RouterGatewayIPQosAgentExtension()
self.context = context.get_admin_context()
self.connection = mock.Mock()
self.policy = policy.QosPolicy(context=None, name='test1', id=_uuid())
self.ingress_rule = (rule.QosBandwidthLimitRule(
context=None,
id=_uuid(),
qos_policy_id=self.policy.id,
max_kbps=1111,
max_burst_kbps=2222,
direction=lib_const.INGRESS_DIRECTION))
self.egress_rule = (rule.QosBandwidthLimitRule(
context=None,
id=_uuid(),
qos_policy_id=self.policy.id,
max_kbps=3333,
max_burst_kbps=4444,
direction=lib_const.EGRESS_DIRECTION))
self.policy.rules = [self.ingress_rule, self.egress_rule]
self.new_ingress_rule = (rule.QosBandwidthLimitRule(
context=None,
id=_uuid(),
qos_policy_id=self.policy.id,
max_kbps=5555,
max_burst_kbps=6666,
direction=lib_const.INGRESS_DIRECTION))
self.ingress_rule_only_has_max_kbps = (rule.QosBandwidthLimitRule(
context=None,
id=_uuid(),
qos_policy_id=self.policy.id,
max_kbps=5555,
max_burst_kbps=0,
direction=lib_const.INGRESS_DIRECTION))
self.policy2 = policy.QosPolicy(context=None, name='test2', id=_uuid())
self.policy2.rules = [self.ingress_rule]
self.policy3 = policy.QosPolicy(context=None, name='test3', id=_uuid())
self.policy3.rules = [self.egress_rule]
self.policy4 = policy.QosPolicy(context=None, name='test4', id=_uuid())
self.dscp = rule.QosDscpMarkingRule(context=None,
id=_uuid(),
qos_policy_id=self.policy4.id,
dscp_mark=32)
self.dscp.obj_reset_changes()
self.policy4.rules = [self.dscp]
self.qos_policies = {
self.policy.id: self.policy,
self.policy2.id: self.policy2,
self.policy3.id: self.policy3,
self.policy4.id: self.policy4
}
self.agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
self.ex_gw_port = {
'id': _uuid(),
'fixed_ips': [{
'ip_address': TEST_QOS_GW_IP
}],
'qos_policy_id': self.policy.id,
'enable_snat': True
}
self.fip = {
'id': _uuid(),
'floating_ip_address': '172.24.4.9',
'fixed_ip_address': '192.168.0.1',
'floating_network_id': _uuid(),
'port_id': _uuid(),
'host': HOSTNAME,
'qos_policy_id': self.policy.id
}
self.router = {
'id': _uuid(),
'gw_port': self.ex_gw_port,
'ha': False,
'distributed': False,
lib_const.FLOATINGIP_KEY: [self.fip],
'external_gateway_info': self.ex_gw_port
}
self.router_info = l3router.RouterInfo(self.agent, self.router['id'],
self.router, **self.ri_kwargs)
self.router_info.ex_gw_port = self.ex_gw_port
self.agent.router_info[self.router['id']] = self.router_info
def _mock_get_router_info(router_id):
return self.router_info
self.get_router_info = mock.patch(
'neutron.agent.l3.l3_agent_extension_api.'
'L3AgentExtensionAPI.get_router_info').start()
self.get_router_info.side_effect = _mock_get_router_info
self.agent_api = l3_ext_api.L3AgentExtensionAPI(None, None)
self.gw_ip_qos_ext.consume_api(self.agent_api)
def delete_policy(self, context, policy_id):
policy = policy_object.QosPolicy(context)
policy.id = policy_id
self.notification_driver_manager.delete_policy(context, policy)
policy.delete()
def test_floatingip_update_with_port_and_qos_scenarios(self):
ctx = context.get_admin_context()
policy_obj_1 = policy.QosPolicy(ctx,
id=uuidutils.generate_uuid(),
project_id='tenant', name='pol2',
rules=[])
policy_obj_1.create()
policy_obj_2 = policy.QosPolicy(ctx,
id=uuidutils.generate_uuid(),
project_id='tenant', name='pol3',
rules=[])
policy_obj_2.create()
with self.network() as ext_net:
network_id = ext_net['network']['id']
self._set_net_external(network_id)
with self.subnet(
ext_net, cidr='10.10.10.0/24'
), self.router() as router, self.subnet(
cidr='11.0.0.0/24') as private_subnet, self.port(
private_subnet) as port_1, self.port(
private_subnet) as port_2:
self._add_external_gateway_to_router(
router['router']['id'],
network_id)
self._router_interface_action(
'add', router['router']['id'],
private_subnet['subnet']['id'],
None)
fip = self._make_floatingip(self.fmt, network_id)
self.assertIsNone(fip['floatingip'].get('port_id'))
self.assertIsNone(
fip['floatingip'].get(qos_consts.QOS_POLICY_ID))
# update from: {port_id: null, qos_policy_id: null}
# to : {port_id: port_id_1, qos_policy_id: null}
self._update_fip_with_port_or_qos_and_verify(
fip['floatingip']['id'],
port_1['port']['id'],
None,
revision_number=fip['floatingip'].get('revision_number'))
# update from: {port_id: port_id_1, qos_policy_id: null}
# to : {port_id: port_id_1, qos_policy_id: policy_1}
self._update_fip_with_port_or_qos_and_verify(
fip['floatingip']['id'],
port_1['port']['id'],
policy_obj_1.id)
# update from: {port_id: port_id_1, qos_policy_id: policy_1}
# to : {port_id: port_id_2, qos_policy_id: policy_2}
self._update_fip_with_port_or_qos_and_verify(
fip['floatingip']['id'],
port_2['port']['id'],
policy_obj_2.id)
# update from: {port_id: port_id_2, qos_policy_id: policy_2}
# to : {port_id: port_id_1, qos_policy_id: null}
self._update_fip_with_port_or_qos_and_verify(
fip['floatingip']['id'],
port_1['port']['id'],
None)
# update from: {port_id: port_id_1, qos_policy_id: null}
# to : {port_id: null, qos_policy_id: policy_1}
self._update_fip_with_port_or_qos_and_verify(
fip['floatingip']['id'],
None,
policy_obj_1.id)
# update from: {port_id: null, qos_policy_id: policy_1}
# to : {port_id: null, qos_policy_id: null}
self._update_fip_with_port_or_qos_and_verify(
fip['floatingip']['id'])
from neutron.objects.qos import rule
from neutron.plugins.ml2.drivers.openvswitch.agent import (
ovs_agent_extension_api as ovs_ext_api)
from neutron.plugins.ml2.drivers.openvswitch.agent.common import constants
from neutron.plugins.ml2.drivers.openvswitch.agent.openflow.ovs_ofctl import (
ovs_bridge)
from neutron.services.qos import qos_consts
from neutron.tests import base
BASE_TEST_POLICY = {
'context': None,
'name': 'test1',
'id': uuidutils.generate_uuid()
}
TEST_POLICY = policy.QosPolicy(**BASE_TEST_POLICY)
TEST_POLICY_DESCR = policy.QosPolicy(description='fake_descr',
**BASE_TEST_POLICY)
TEST_POLICY2 = policy.QosPolicy(context=None,
name='test2',
id=uuidutils.generate_uuid())
TEST_PORT = {'port_id': 'test_port_id', 'qos_policy_id': TEST_POLICY.id}
TEST_PORT2 = {'port_id': 'test_port_id_2', 'qos_policy_id': TEST_POLICY2.id}
FAKE_RULE_ID = uuidutils.generate_uuid()
REALLY_FAKE_RULE_ID = uuidutils.generate_uuid()
def create_policy(self, context, policy):
policy = policy_object.QosPolicy(context, **policy['policy'])
policy.create()
self.notification_driver_manager.create_policy(context, policy)
return policy
from oslo_utils import uuidutils
from neutron.agent.l2.extensions import qos
from neutron.api.rpc.callbacks.consumer import registry
from neutron.api.rpc.callbacks import events
from neutron.api.rpc.callbacks import resources
from neutron.api.rpc.handlers import resources_rpc
from neutron.common import exceptions
from neutron import context
from neutron.objects.qos import policy
from neutron.objects.qos import rule
from neutron.plugins.ml2.drivers.openvswitch.agent.common import constants
from neutron.services.qos import qos_consts
from neutron.tests import base
TEST_POLICY = policy.QosPolicy(context=None, name='test1', id='fake_policy_id')
TEST_POLICY2 = policy.QosPolicy(context=None,
name='test2',
id='fake_policy_id_2')
TEST_PORT = {'port_id': 'test_port_id', 'qos_policy_id': TEST_POLICY.id}
TEST_PORT2 = {'port_id': 'test_port_id_2', 'qos_policy_id': TEST_POLICY2.id}
class FakeDriver(qos.QosAgentDriver):
SUPPORTED_RULES = {qos_consts.RULE_TYPE_BANDWIDTH_LIMIT}
def __init__(self):
super(FakeDriver, self).__init__()