86118f6692
This patch refactors the current codebase to be more modular
and testable. The main changes are:
- pull out all of the profile setup logic from the __init__
method to it's own method _init_nsx_profiles method to make
testing the code easier.
- refactors the nsxlib.v3 code to break out all neutron related
exceptions and cleans up the interface so we can make nsxlib.v3
it's own standalone library eventually.
To improve:
- Currently we have nsxlib.v3.dfw_api and nsxlib.v3.firewall,
we should refactor this code and merge them into one file.
- refactor nsxlib to section of each api component to it's own
subclass. For example, nsxlib().port.create() rather than
nsxlib().create_port(). I think this would be most useful
for the security group/firewall integration as there are many
methods there that are needed to interface with nsx as the security
group feature is requires the most orchestration with nsx.
Breaking them into a sub class will make things more easy to understand.
Change-Id: If2fe1e014b78703ff0a9cdff1e4e8d45f3a4a16d
191 lines
7.2 KiB
Python
191 lines
7.2 KiB
Python
# Copyright 2016 VMware, Inc.
|
|
#
|
|
# All Rights Reserved
|
|
#
|
|
# 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.
|
|
|
|
from neutron.api.rpc.callbacks import events as callbacks_events
|
|
from neutron import context as n_context
|
|
from neutron import manager
|
|
from neutron.objects.qos import policy as qos_policy
|
|
from neutron.services.qos import qos_consts
|
|
from neutron_lib.api import validators
|
|
from oslo_config import cfg
|
|
from oslo_log import log as logging
|
|
|
|
from vmware_nsx._i18n import _, _LW
|
|
from vmware_nsx.common import exceptions as nsx_exc
|
|
from vmware_nsx.common import utils
|
|
from vmware_nsx.db import db as nsx_db
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
MAX_KBPS_MIN_VALUE = 1024
|
|
|
|
|
|
def handle_qos_notification(policy_obj, event_type):
|
|
handler = QosNotificationsHandler()
|
|
context = n_context.get_admin_context()
|
|
|
|
# Reload the policy as admin so we will have a context
|
|
if (event_type != callbacks_events.DELETED):
|
|
policy = qos_policy.QosPolicy.get_object(context, id=policy_obj.id)
|
|
|
|
# Check if QoS policy rule was created/deleted/updated
|
|
if (event_type == callbacks_events.CREATED):
|
|
handler.create_policy(context, policy)
|
|
|
|
elif (event_type == callbacks_events.UPDATED):
|
|
if (hasattr(policy_obj, "rules")):
|
|
# Rebuild the QoS data of this policy
|
|
# we may have up to 1 rule of each type
|
|
bw_rule = None
|
|
dscp_rule = None
|
|
for rule in policy_obj["rules"]:
|
|
if rule.rule_type == qos_consts.RULE_TYPE_BANDWIDTH_LIMIT:
|
|
bw_rule = rule
|
|
else:
|
|
dscp_rule = rule
|
|
|
|
handler.update_policy_rules(
|
|
context, policy_obj.id, bw_rule, dscp_rule)
|
|
else:
|
|
# Without rules - need to update only name / description
|
|
handler.update_policy(context, policy_obj.id, policy)
|
|
|
|
elif (event_type == callbacks_events.DELETED):
|
|
handler.delete_policy(context, policy_obj.id)
|
|
|
|
else:
|
|
msg = _("Unknown QoS notification event %s") % event_type
|
|
raise nsx_exc.NsxPluginException(err_msg=msg)
|
|
|
|
|
|
class QosNotificationsHandler(object):
|
|
|
|
def __init__(self):
|
|
super(QosNotificationsHandler, self).__init__()
|
|
|
|
@property
|
|
def _core_plugin(self):
|
|
return manager.NeutronManager.get_plugin()
|
|
|
|
def _get_tags(self, context, policy):
|
|
policy_dict = {'id': policy.id, 'tenant_id': policy.tenant_id}
|
|
return utils.build_v3_tags_payload(
|
|
policy_dict, resource_type='os-neutron-qos-id',
|
|
project_name=context.tenant_name)
|
|
|
|
def create_policy(self, context, policy):
|
|
policy_id = policy.id
|
|
tags = self._get_tags(context, policy)
|
|
result = self._core_plugin.nsxlib.create_qos_switching_profile(
|
|
tags=tags, name=policy.name,
|
|
description=policy.description)
|
|
if not result or not validators.is_attr_set(result.get('id')):
|
|
msg = _("Unable to create QoS switching profile on the backend")
|
|
raise nsx_exc.NsxPluginException(err_msg=msg)
|
|
profile_id = result['id']
|
|
|
|
# Add the mapping entry of the policy_id <-> profile_id
|
|
nsx_db.add_qos_policy_profile_mapping(context.session,
|
|
policy_id,
|
|
profile_id)
|
|
|
|
def delete_policy(self, context, policy_id):
|
|
profile_id = nsx_db.get_switch_profile_by_qos_policy(
|
|
context.session, policy_id)
|
|
self._core_plugin.nsxlib.delete_qos_switching_profile(profile_id)
|
|
|
|
def update_policy(self, context, policy_id, policy):
|
|
profile_id = nsx_db.get_switch_profile_by_qos_policy(
|
|
context.session, policy_id)
|
|
tags = self._get_tags(context, policy)
|
|
self._core_plugin.nsxlib.update_qos_switching_profile(
|
|
profile_id,
|
|
tags=tags,
|
|
name=policy.name,
|
|
description=policy.description)
|
|
|
|
def _get_bw_values_from_rule(self, bw_rule):
|
|
"""Translate the neutron bandwidth_limit_rule values, into the
|
|
values expected by the NSX-v3 QoS switch profile,
|
|
and validate that those are legal
|
|
"""
|
|
if bw_rule:
|
|
shaping_enabled = True
|
|
|
|
# validate the max_kbps - it must be at least 1Mbps for the
|
|
# switch profile configuration to succeed.
|
|
if (bw_rule.max_kbps < MAX_KBPS_MIN_VALUE):
|
|
# Since failing the action from the notification callback
|
|
# is not possible, just log the warning and use the
|
|
# minimal value.
|
|
LOG.warning(_LW("Invalid input for max_kbps. "
|
|
"The minimal legal value is 1024"))
|
|
bw_rule.max_kbps = MAX_KBPS_MIN_VALUE
|
|
|
|
# 'None' value means we will keep the old value
|
|
burst_size = peak_bandwidth = average_bandwidth = None
|
|
|
|
# translate kbps -> bytes
|
|
burst_size = int(bw_rule.max_burst_kbps) * 128
|
|
|
|
# translate kbps -> Mbps
|
|
average_bandwidth = int(float(bw_rule.max_kbps) / 1024)
|
|
|
|
# peakBandwidth: a Multiplying on the average BW
|
|
# because the neutron qos configuration supports
|
|
# only 1 value
|
|
peak_bandwidth = int(average_bandwidth *
|
|
cfg.CONF.NSX.qos_peak_bw_multiplier)
|
|
else:
|
|
shaping_enabled = False
|
|
burst_size = None
|
|
peak_bandwidth = None
|
|
average_bandwidth = None
|
|
|
|
return shaping_enabled, burst_size, peak_bandwidth, average_bandwidth
|
|
|
|
def _get_dscp_values_from_rule(self, dscp_rule):
|
|
"""Translate the neutron DSCP marking rule values, into the
|
|
values expected by the NSX-v3 QoS switch profile
|
|
"""
|
|
if dscp_rule:
|
|
qos_marking = 'untrusted'
|
|
dscp = dscp_rule.dscp_mark
|
|
else:
|
|
qos_marking = 'trusted'
|
|
dscp = 0
|
|
|
|
return qos_marking, dscp
|
|
|
|
def update_policy_rules(self, context, policy_id, bw_rule, dscp_rule):
|
|
"""Update the QoS switch profile with the BW limitations and
|
|
DSCP marking configuration
|
|
"""
|
|
profile_id = nsx_db.get_switch_profile_by_qos_policy(
|
|
context.session, policy_id)
|
|
|
|
(shaping_enabled, burst_size, peak_bw,
|
|
average_bw) = self._get_bw_values_from_rule(bw_rule)
|
|
|
|
qos_marking, dscp = self._get_dscp_values_from_rule(dscp_rule)
|
|
self._core_plugin.nsxlib.update_qos_switching_profile_shaping(
|
|
profile_id,
|
|
shaping_enabled=shaping_enabled,
|
|
burst_size=burst_size,
|
|
peak_bandwidth=peak_bw,
|
|
average_bandwidth=average_bw,
|
|
qos_marking=qos_marking,
|
|
dscp=dscp)
|