x/vmware-nsx
Code Issues Proposed changes

Integration with new neutron code

Browse Source 
1. Use new enginefacade + l3_db breakage
Use reader and writer for db operations.
Partially-Implements blueprint: enginefacade-switch

2. Fix the callback pass for _prevent_l3_port_delete_callback
which was changed in commit Ia8ac4f510c003667cac95f76dea0e9ae55159878

3. QoS driver integration
Commit I5f747635be3fd66b70326d9f94c85a6736286bd2 removes the qos
notification driver.
Fixing the nsx-v and nsx-v3 to work only with the regular driver

4. _get_extra_routes_dict_by_router_id was removed by
Ia815d6c597730bd5cb49455e7409ca747a4cc22c

5. Floating IP association without subnet gateway IP
not supported by our plugins.
Added in commit If212c36d918ed57400a53f4b5fa1925b3d1fa6fd

Co-Authored-by: Adit Sarfaty <asarfaty@vmware.com>
Change-Id: I277ec5c38c5895337011019f71d586b254bfafde
This commit is contained in:
Gary Kotton 2017-04-01 23:06:41 -07:00 committed by Adit Sarfaty
parent bf3bbb5c4c
commit 01d33ffa65
31 changed files with 390 additions and 477 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
doc/source/devstack.rst
View File

@ -135,9 +135,6 @@ Enable the qos in ``local.conf``::
[DEFAULT]
service_plugins = neutron.services.qos.qos_plugin.QoSPlugin
[qos]
notification_drivers =
Optional: Update the nsx qos_peak_bw_multiplier in nsx.ini (default value is 2.0)::
[NSX]

13
vmware_nsx/common/sync.py
View File

@ -17,7 +17,7 @@ import copy
import random
from neutron_lib import constants
from neutron_lib import context
from neutron_lib import context as n_context
from neutron_lib import exceptions
from oslo_log import log
from oslo_serialization import jsonutils
@ -25,6 +25,7 @@ from oslo_service import loopingcall
from oslo_utils import timeutils
import six
from neutron.db import api as db_api
from neutron.db.models import external_net as external_net_db
from neutron.db.models import l3 as l3_db
from neutron.db import models_v2
@ -300,7 +301,7 @@ class NsxSynchronizer(object):
# do nothing
return
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
try:
network = self._plugin._get_network(context,
neutron_network_data['id'])
@ -382,7 +383,7 @@ class NsxSynchronizer(object):
# do nothing
return
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
try:
router = self._plugin._get_router(context,
neutron_router_data['id'])
@ -434,7 +435,7 @@ class NsxSynchronizer(object):
(models_v2.Network.id ==
external_net_db.ExternalNetwork.network_id))]
if neutron_port_data['network_id'] in ext_networks:
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
neutron_port_data['status'] = constants.PORT_STATUS_ACTIVE
return
@ -477,7 +478,7 @@ class NsxSynchronizer(object):
# do nothing
return
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
try:
port = self._plugin._get_port(context,
neutron_port_data['id'])
@ -660,7 +661,7 @@ class NsxSynchronizer(object):
LOG.debug("Time elapsed hashing data: %s",
timeutils.utcnow() - start)
# Get an admin context
ctx = context.get_admin_context()
ctx = n_context.get_admin_context()
# Synchronize with database
self._synchronize_lswitches(ctx, ls_uuids,
scan_missing=scan_missing)

16
vmware_nsx/db/db.py
View File

@ -402,14 +402,14 @@ def delete_port_mirror_session_mapping(session, tf_id):
filter_by(tap_flow_id=tf_id).delete())
def save_sg_mappings(session, sg_id, nsgroup_id, section_id):
with session.begin(subtransactions=True):
session.add(
nsx_models.NeutronNsxFirewallSectionMapping(neutron_id=sg_id,
nsx_id=section_id))
session.add(
nsx_models.NeutronNsxSecurityGroupMapping(neutron_id=sg_id,
nsx_id=nsgroup_id))
@db.context_manager.writer
def save_sg_mappings(context, sg_id, nsgroup_id, section_id):
context.session.add(
nsx_models.NeutronNsxFirewallSectionMapping(neutron_id=sg_id,
nsx_id=section_id))
context.session.add(
nsx_models.NeutronNsxSecurityGroupMapping(neutron_id=sg_id,
nsx_id=nsgroup_id))
def get_sg_mappings(session, sg_id):

6
vmware_nsx/db/extended_security_group.py
View File

@ -120,7 +120,7 @@ class ExtendedSecurityGroupPropertiesMixin(object):
default_sg=False):
self._validate_security_group_properties_create(
context, sg_req, default_sg)
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
properties = NsxExtendedSecurityGroupProperties(
security_group_id=sg_res['id'],
logging=sg_req.get(sg_logging.LOGGING, False),
@ -132,7 +132,7 @@ class ExtendedSecurityGroupPropertiesMixin(object):
sg_res[sg_policy.POLICY] = sg_req.get(sg_policy.POLICY)
def _get_security_group_properties(self, context, security_group_id):
with context.session.begin(subtransactions=True):
with db_api.context_manager.reader.using(context):
try:
prop = context.session.query(
NsxExtendedSecurityGroupProperties).filter_by(
@ -150,7 +150,7 @@ class ExtendedSecurityGroupPropertiesMixin(object):
and (sg_req[sg_policy.POLICY] !=
sg_res.get(sg_policy.POLICY)))):
prop = self._get_security_group_properties(context, sg_res['id'])
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
prop.update({
sg_logging.LOGGING: sg_req.get(sg_logging.LOGGING, False),
sg_policy.POLICY: sg_req.get(sg_policy.POLICY)})

3
vmware_nsx/db/extended_security_group_rule.py
View File

@ -17,6 +17,7 @@ from neutron_lib.db import model_base
import sqlalchemy as sa
from sqlalchemy import orm
from neutron.db import api as db_api
from neutron.db import db_base_plugin_v2
from neutron.db.models import securitygroup
from neutron.extensions import securitygroup as ext_sg
@ -72,7 +73,7 @@ class ExtendedSecurityGroupRuleMixin(object):
rule_req.get(ext_local_ip.LOCAL_IP_PREFIX)):
return
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
properties = NsxExtendedSecurityGroupRuleProperties(
rule_id=rule_res['id'],
local_ip_prefix=rule_req[ext_local_ip.LOCAL_IP_PREFIX])

15
vmware_nsx/db/lsn_db.py
View File

@ -23,26 +23,27 @@ from vmware_nsx._i18n import _
from vmware_nsx.common import exceptions as p_exc
from vmware_nsx.db import nsx_models
from neutron.db import api as db_api
LOG = logging.getLogger(__name__)
def lsn_add(context, network_id, lsn_id):
"""Add Logical Service Node information to persistent datastore."""
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
lsn = nsx_models.Lsn(network_id, lsn_id)
context.session.add(lsn)
def lsn_remove(context, lsn_id):
"""Remove Logical Service Node information from datastore given its id."""
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
context.session.query(nsx_models.Lsn).filter_by(lsn_id=lsn_id).delete()
def lsn_remove_for_network(context, network_id):
"""Remove information about the Logical Service Node given its network."""
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
context.session.query(nsx_models.Lsn).filter_by(
net_id=network_id).delete()
@ -64,14 +65,14 @@ def lsn_get_for_network(context, network_id, raise_on_err=True):
def lsn_port_add_for_lsn(context, lsn_port_id, subnet_id, mac, lsn_id):
"""Add Logical Service Node Port information to persistent datastore."""
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
lsn_port = nsx_models.LsnPort(lsn_port_id, subnet_id, mac, lsn_id)
context.session.add(lsn_port)
def lsn_port_get_for_subnet(context, subnet_id, raise_on_err=True):
"""Return Logical Service Node Port information given its subnet id."""
with context.session.begin(subtransactions=True):
with db_api.context_manager.reader.using(context):
try:
return (context.session.query(nsx_models.LsnPort).
filter_by(sub_id=subnet_id).one())
@ -84,7 +85,7 @@ def lsn_port_get_for_subnet(context, subnet_id, raise_on_err=True):
def lsn_port_get_for_mac(context, mac_address, raise_on_err=True):
"""Return Logical Service Node Port information given its mac address."""
with context.session.begin(subtransactions=True):
with db_api.context_manager.reader.using(context):
try:
return (context.session.query(nsx_models.LsnPort).
filter_by(mac_addr=mac_address).one())
@ -97,6 +98,6 @@ def lsn_port_get_for_mac(context, mac_address, raise_on_err=True):
def lsn_port_remove(context, lsn_port_id):
"""Remove Logical Service Node port from the given Logical Service Node."""
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
(context.session.query(nsx_models.LsnPort).
filter_by(lsn_port_id=lsn_port_id).delete())

3
vmware_nsx/db/maclearning.py
View File

@ -17,6 +17,7 @@ from sqlalchemy.orm import exc
from neutron.api.v2 import attributes
from neutron.db import _utils as db_utils
from neutron.db import api as db_api
from neutron.db import db_base_plugin_v2
from oslo_log import log as logging
@ -56,7 +57,7 @@ class MacLearningDbMixin(object):
mac.MAC_LEARNING: enabled})
def _create_mac_learning_state(self, context, port):
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
enabled = port[mac.MAC_LEARNING]
state = nsx_models.MacLearningState(
port_id=port['id'],

29
vmware_nsx/db/networkgw_db.py
View File

@ -15,6 +15,7 @@
from sqlalchemy.orm import exc as sa_orm_exc
from neutron.db import _utils as db_utils
from neutron.db import api as db_api
from neutron.plugins.common import utils
from neutron_lib import constants
from neutron_lib import exceptions
@ -177,12 +178,12 @@ class NetworkGatewayMixin(networkgw.NetworkGatewayPluginBase):
return query.one() if only_one else query.all()
def _unset_default_network_gateways(self, context):
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
context.session.query(nsx_models.NetworkGateway).update(
{nsx_models.NetworkGateway.default: False})
def _set_default_network_gateway(self, context, gw_id):
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
gw = (context.session.query(nsx_models.NetworkGateway).
filter_by(id=gw_id).one())
gw['default'] = True
@ -217,7 +218,7 @@ class NetworkGatewayMixin(networkgw.NetworkGatewayPluginBase):
validate_device_list=True):
gw_data = network_gateway[self.gateway_resource]
tenant_id = gw_data['tenant_id']
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
gw_db = nsx_models.NetworkGateway(
id=gw_data.get('id', uuidutils.generate_uuid()),
tenant_id=tenant_id,
@ -230,27 +231,27 @@ class NetworkGatewayMixin(networkgw.NetworkGatewayPluginBase):
[nsx_models.NetworkGatewayDeviceReference(**device)
for device in gw_data['devices']])
context.session.add(gw_db)
LOG.debug("Created network gateway with id:%s", gw_db['id'])
return self._make_network_gateway_dict(gw_db)
LOG.debug("Created network gateway with id:%s", gw_db['id'])
return self._make_network_gateway_dict(gw_db)
def update_network_gateway(self, context, id, network_gateway):
gw_data = network_gateway[self.gateway_resource]
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
gw_db = self._get_network_gateway(context, id)
if gw_db.default:
raise NetworkGatewayUnchangeable(gateway_id=id)
# Ensure there is something to update before doing it
if any([gw_db[k] != gw_data[k] for k in gw_data]):
gw_db.update(gw_data)
LOG.debug("Updated network gateway with id:%s", id)
return self._make_network_gateway_dict(gw_db)
LOG.debug("Updated network gateway with id:%s", id)
return self._make_network_gateway_dict(gw_db)
def get_network_gateway(self, context, id, fields=None):
gw_db = self._get_network_gateway(context, id)
return self._make_network_gateway_dict(gw_db, fields)
def delete_network_gateway(self, context, id):
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
gw_db = self._get_network_gateway(context, id)
if gw_db.network_connections:
raise GatewayInUse(gateway_id=id)
@ -278,7 +279,7 @@ class NetworkGatewayMixin(networkgw.NetworkGatewayPluginBase):
"'%(network_gateway_id)s'",
{'network_id': network_id,
'network_gateway_id': network_gateway_id})
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
gw_db = self._get_network_gateway(context, network_gateway_id)
tenant_id = gw_db['tenant_id']
if context.is_admin and not tenant_id:
@ -355,7 +356,7 @@ class NetworkGatewayMixin(networkgw.NetworkGatewayPluginBase):
"'%(network_gateway_id)s'",
{'network_id': network_id,
'network_gateway_id': network_gateway_id})
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
# Uniquely identify connection, otherwise raise
try:
net_connection = self._retrieve_gateway_connections(
@ -439,7 +440,7 @@ class NetworkGatewayMixin(networkgw.NetworkGatewayPluginBase):
initial_status=STATUS_UNKNOWN):
device_data = gateway_device[self.device_resource]
tenant_id = device_data['tenant_id']
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
device_db = nsx_models.NetworkGatewayDevice(
id=device_data.get('id', uuidutils.generate_uuid()),
tenant_id=tenant_id,
@ -454,7 +455,7 @@ class NetworkGatewayMixin(networkgw.NetworkGatewayPluginBase):
def update_gateway_device(self, context, gateway_device_id,
gateway_device, include_nsx_id=False):
device_data = gateway_device[self.device_resource]
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
device_db = self._get_gateway_device(context, gateway_device_id)
# Ensure there is something to update before doing it
if any([device_db[k] != device_data[k] for k in device_data]):
@ -465,7 +466,7 @@ class NetworkGatewayMixin(networkgw.NetworkGatewayPluginBase):
device_db, include_nsx_id=include_nsx_id)
def delete_gateway_device(self, context, device_id):
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
# A gateway device should not be deleted
# if it is used in any network gateway service
if self._is_device_in_use(context, device_id):

15
vmware_nsx/db/qos_db.py
View File

@ -17,6 +17,7 @@ from sqlalchemy.orm import exc
from neutron.api.v2 import attributes as attr
from neutron.db import _utils as db_utils
from neutron.db import api as db_api
from neutron.db import db_base_plugin_v2
from neutron.db import models_v2
@ -34,7 +35,7 @@ class QoSDbMixin(qos.QueuePluginBase):
def create_qos_queue(self, context, qos_queue):
q = qos_queue['qos_queue']
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
qos_queue = nsx_models.QoSQueue(
id=q.get('id', uuidutils.generate_uuid()),
name=q.get('name'),
@ -68,15 +69,15 @@ class QoSDbMixin(qos.QueuePluginBase):
page_reverse=page_reverse)
def delete_qos_queue(self, context, queue_id):
qos_queue = self._get_qos_queue(context, queue_id)
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
qos_queue = self._get_qos_queue(context, queue_id)
context.session.delete(qos_queue)
def _process_port_queue_mapping(self, context, port_data, queue_id):
port_data[qos.QUEUE] = queue_id
if not queue_id:
return
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
context.session.add(nsx_models.PortQueueMapping(
port_id=port_data['id'],
queue_id=queue_id))
@ -96,14 +97,14 @@ class QoSDbMixin(qos.QueuePluginBase):
# did not already have a queue on it. There is no need to check
# if there is one before deleting if we return here.
return
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
context.session.delete(binding)
def _process_network_queue_mapping(self, context, net_data, queue_id):
net_data[qos.QUEUE] = queue_id
if not queue_id:
return
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
context.session.add(
nsx_models.NetworkQueueMapping(network_id=net_data['id'],
queue_id=queue_id))
@ -115,7 +116,7 @@ class QoSDbMixin(qos.QueuePluginBase):
def _delete_network_queue_mapping(self, context, network_id):
query = self._model_query(context, nsx_models.NetworkQueueMapping)
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
binding = query.filter_by(network_id=network_id).first()
if binding:
context.session.delete(binding)

3
vmware_nsx/db/routertype.py
View File

@ -14,6 +14,7 @@
# under the License.
#
from vmware_nsx.common import nsxv_constants
from vmware_nsx.db import (
distributedrouter as dist_rtr)
from vmware_nsx.extensions import routertype as rt_rtr
@ -25,5 +26,5 @@ class RouterType_mixin(dist_rtr.DistributedRouter_mixin):
nsx_attributes = (
dist_rtr.DistributedRouter_mixin.nsx_attributes + [{
'name': rt_rtr.ROUTER_TYPE,
'default': False
'default': nsxv_constants.SHARED
}])

6
vmware_nsx/plugins/dvs/plugin.py
View File

@ -346,7 +346,7 @@ class NsxDvsV2(addr_pair_db.AllowedAddressPairsMixin,
# shared network that is not owned by the tenant.
port_data = port['port']
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
# First we allocate port in neutron database
neutron_db = super(NsxDvsV2, self).create_port(context, port)
port_security = self._get_network_security_binding(
@ -407,7 +407,7 @@ class NsxDvsV2(addr_pair_db.AllowedAddressPairsMixin,
port)
has_addr_pairs = self._check_update_has_allowed_address_pairs(port)
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
ret_port = super(NsxDvsV2, self).update_port(
context, id, port)
# Save current mac learning state to check whether it's
@ -463,7 +463,7 @@ class NsxDvsV2(addr_pair_db.AllowedAddressPairsMixin,
"""
neutron_db_port = self.get_port(context, id)
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
# metadata_dhcp_host_route
self.handle_port_metadata_access(
context, neutron_db_port, is_delete=True)

117
vmware_nsx/plugins/nsx_mh/plugin.py
View File

@ -1032,7 +1032,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
LOG.debug("Delete network complete for network: %s", id)
def get_network(self, context, id, fields=None):
with db_api.context_manager.reader.using(context):
with db_api.context_manager.writer.using(context):
# goto to the plugin DB and fetch the network
network = self._get_network(context, id)
if (self.nsx_sync_opts.always_read_status or
@ -1112,7 +1112,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
dhcp_opts = port_data.get(edo_ext.EXTRADHCPOPTS, [])
# Set port status as 'DOWN'. This will be updated by backend sync.
port_data['status'] = constants.PORT_STATUS_DOWN
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
# First we allocate port in neutron database
neutron_db = super(NsxPluginV2, self).create_port(context, port)
neutron_port_id = neutron_db['id']
@ -1182,7 +1182,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
LOG.warning("Logical switch for network %s was not "
"found in NSX.", port_data['network_id'])
# Put port in error on neutron DB
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
port = self._get_port(context, neutron_port_id)
port_data['status'] = constants.PORT_STATUS_ERROR
port['status'] = port_data['status']
@ -1192,7 +1192,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
with excutils.save_and_reraise_exception():
LOG.error("Unable to create port or set port "
"attachment in NSX.")
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
self.ipam.delete_port(context, neutron_port_id)
# this extra lookup is necessary to get the
# latest db model for the extension functions
@ -1209,7 +1209,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
port)
has_addr_pairs = self._check_update_has_allowed_address_pairs(port)
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
ret_port = super(NsxPluginV2, self).update_port(
context, id, port)
@ -1357,7 +1357,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
port_delete_func(context, neutron_db_port)
self.disassociate_floatingips(context, id)
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
queue = self._get_port_queue_bindings(context, {'port_id': [id]})
# metadata_dhcp_host_route
self.handle_port_metadata_access(
@ -1370,7 +1370,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
context, neutron_db_port, action='delete_port')
def get_port(self, context, id, fields=None):
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
if (self.nsx_sync_opts.always_read_status or
fields and 'status' in fields):
# Perform explicit state synchronization
@ -1382,15 +1382,16 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
return super(NsxPluginV2, self).get_port(context, id, fields)
def get_router(self, context, id, fields=None):
if (self.nsx_sync_opts.always_read_status or
fields and 'status' in fields):
db_router = self._get_router(context, id)
# Perform explicit state synchronization
self._synchronizer.synchronize_router(
context, db_router)
return self._make_router_dict(db_router, fields)
else:
return super(NsxPluginV2, self).get_router(context, id, fields)
with db_api.context_manager.writer.using(context):
if (self.nsx_sync_opts.always_read_status or
fields and 'status' in fields):
db_router = self._get_router(context, id)
# Perform explicit state synchronization
self._synchronizer.synchronize_router(
context, db_router)
return self._make_router_dict(db_router, fields)
else:
return super(NsxPluginV2, self).get_router(context, id, fields)
def _create_lrouter(self, context, router, nexthop):
tenant_id = router['tenant_id']
@ -1482,10 +1483,10 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
lrouter = self._create_lrouter(context, r, nexthop)
# TODO(salv-orlando): Deal with backend object removal in case
# of db failures
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
# Transaction nesting is needed to avoid foreign key violations
# when processing the distributed router binding
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
router_db = l3_db_models.Router(
id=neutron_router_id,
tenant_id=tenant_id,
@ -1500,27 +1501,28 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
nsx_db.add_neutron_nsx_router_mapping(
context.session, router_db['id'], lrouter['uuid'])
if has_gw_info:
# NOTE(salv-orlando): This operation has been moved out of the
# database transaction since it performs several NSX queries,
# ithis ncreasing the risk of deadlocks between eventlet and
# sqlalchemy operations.
# Set external gateway and remove router in case of failure
try:
self._update_router_gw_info(context, router_db['id'], gw_info)
except (n_exc.NeutronException, api_exc.NsxApiException):
with excutils.save_and_reraise_exception():
# As setting gateway failed, the router must be deleted
# in order to ensure atomicity
router_id = router_db['id']
LOG.warning("Failed to set gateway info for router "
"being created:%s - removing router",
router_id)
self.delete_router(context, router_id)
LOG.info("Create router failed while setting external "
"gateway. Router:%s has been removed from "
"DB and backend",
router_id)
if has_gw_info:
# NOTE(salv-orlando): This operation has been moved out of the
# database transaction since it performs several NSX queries,
# ithis ncreasing the risk of deadlocks between eventlet and
# sqlalchemy operations.
# Set external gateway and remove router in case of failure
try:
self._update_router_gw_info(context, router_db['id'],
gw_info)
except (n_exc.NeutronException, api_exc.NsxApiException):
with excutils.save_and_reraise_exception():
# As setting gateway failed, the router must be deleted
# in order to ensure atomicity
router_id = router_db['id']
LOG.warning("Failed to set gateway info for router "
"being created:%s - removing router",
router_id)
self.delete_router(context, router_id)
LOG.info("Create router failed while setting external "
"gateway. Router:%s has been removed from "
"DB and backend",
router_id)
return self._make_router_dict(router_db)
def _update_lrouter(self, context, router_id, name, nexthop, routes=None):
@ -1571,7 +1573,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
# object is not found in the underlying backend
except n_exc.NotFound:
# Put the router in ERROR status
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
router_db = self._get_router(context, router_id)
router_db['status'] = constants.NET_STATUS_ERROR
raise nsx_exc.NsxPluginException(
@ -1603,7 +1605,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
routerlib.delete_lrouter(self.cluster, nsx_router_id)
def delete_router(self, context, router_id):
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
# NOTE(salv-orlando): These checks will be repeated anyway when
# calling the superclass. This is wasteful, but is the simplest
# way of ensuring a consistent removal of the router both in
@ -1969,12 +1971,21 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
msg = _("Failed to update NAT rules for floatingip update")
raise nsx_exc.NsxPluginException(err_msg=msg)
# Update also floating ip status (no need to call base class method)
new_status = self._floatingip_status(floatingip_db, router_id)
floatingip_db.update(
{'fixed_ip_address': internal_ip,
'fixed_port_id': port_id,
'router_id': router_id,
'status': self._floatingip_status(floatingip_db, router_id)})
return floatingip_db
'status': new_status})
return {'fixed_ip_address': internal_ip,
'fixed_port_id': port_id,
'router_id': router_id,
'last_known_router_id': None,
'floating_ip_address': floatingip_db.floating_ip_address,
'floating_network_id': floatingip_db.floating_network_id,
'floating_ip_id': floatingip_db.id,
'context': context}
@lockutils.synchronized('vmware', 'neutron-')
def create_floatingip(self, context, floatingip):
@ -2077,7 +2088,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
"""
# Ensure the default gateway in the config file is in sync with the db
self._ensure_default_network_gateway()
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
try:
super(NsxPluginV2, self).delete_network_gateway(
context, gateway_id)
@ -2143,7 +2154,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
new_status=None, is_create=False):
LOG.error("Rolling back database changes for gateway device %s "
"because of an error in the NSX backend", device_id)
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
query = self._model_query(
context, nsx_models.NetworkGatewayDevice).filter(
nsx_models.NetworkGatewayDevice.id == device_id)
@ -2179,7 +2190,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
nsx_res['uuid'])
# set NSX GW device in neutron database and update status
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
query = self._model_query(
context, nsx_models.NetworkGatewayDevice).filter(
nsx_models.NetworkGatewayDevice.id == neutron_id)
@ -2218,7 +2229,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
device_status = nsx_utils.get_nsx_device_status(self.cluster,
nsx_id)
# update status
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
query = self._model_query(
context, nsx_models.NetworkGatewayDevice).filter(
nsx_models.NetworkGatewayDevice.id == neutron_id)
@ -2253,7 +2264,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
device_status = nsx_utils.get_nsx_device_status(self.cluster, nsx_id)
# TODO(salv-orlando): Asynchronous sync for gateway device status
# Update status in database
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
query = self._model_query(
context, nsx_models.NetworkGatewayDevice).filter(
nsx_models.NetworkGatewayDevice.id == device_id)
@ -2274,7 +2285,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
nsx_statuses = nsx_utils.get_nsx_device_statuses(self.cluster,
tenant_id)
# Update statuses in database
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
for device in devices:
new_status = nsx_statuses.get(device['nsx_id'])
if new_status:
@ -2349,7 +2360,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
neutron_id = str(uuid.uuid4())
nsx_secgroup = secgrouplib.create_security_profile(
self.cluster, tenant_id, neutron_id, s)
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
s['id'] = neutron_id
sec_group = super(NsxPluginV2, self).create_security_group(
context, security_group, default_sg)
@ -2386,7 +2397,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
:param security_group_id: security group rule to remove.
"""
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
security_group = super(NsxPluginV2, self).get_security_group(
context, security_group_id)
if not security_group:
@ -2458,7 +2469,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
# TODO(arosen) is there anyway we could avoid having the update of
# the security group rules in nsx outside of this transaction?
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
security_group_id = self._validate_security_group_rules(
context, security_group_rules)
# Check to make sure security group exists
@ -2488,7 +2499,7 @@ class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin,
"""Delete a security group rule
:param sgrid: security group id to remove.
"""
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
# determine security profile id
security_group_rule = (
super(NsxPluginV2, self).get_security_group_rule(

2
vmware_nsx/plugins/nsx_v/drivers/distributed_router_driver.py
View File

@ -395,7 +395,7 @@ class RouterDistributedDriver(router_driver.RouterBaseDriver):
for port in vdr_ports:
subnet_id = port['fixed_ips'][0]['subnet_id']
port_subnet = self.plugin.get_subnet(
context, subnet_id)
context.elevated(), subnet_id)
if (port_subnet['id'] != subnet['id']
and port_subnet['enable_dhcp']):
# We already have a subnet which is connected to

50
vmware_nsx/plugins/nsx_v/plugin.py
View File

@ -33,9 +33,6 @@ from oslo_utils import uuidutils
from sqlalchemy.orm import exc as sa_exc
from neutron.api import extensions as neutron_extensions
from neutron.api.rpc.callbacks.consumer import registry as callbacks_registry
from neutron.api.rpc.callbacks import resources as callbacks_resources
from neutron.api.rpc.handlers import resources_rpc
from neutron.api.v2 import attributes as attr
from neutron.callbacks import events
from neutron.callbacks import registry
@ -85,6 +82,7 @@ from neutron.services.qos import qos_consts
from neutron_lib.api.definitions import portbindings as pbin
from vmware_nsx.dvs import dvs
from vmware_nsx.services.qos.common import utils as qos_com_utils
from vmware_nsx.services.qos.nsx_v import driver as qos_driver
from vmware_nsx.services.qos.nsx_v import utils as qos_utils
import vmware_nsx
@ -272,10 +270,6 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
# Only expose the extension if it is supported
self.supported_extension_aliases.append("dhcp-mtu")
# Bind QoS notifications
callbacks_registry.register(self._handle_qos_notification,
callbacks_resources.QOS_POLICY)
# Make sure starting rpc listeners (for QoS and other agents)
# will happen only once
self.start_rpc_listeners_called = False
@ -292,6 +286,9 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
if c_utils.is_nsxv_version_6_2(self.nsx_v.vcns.get_version()):
self.supported_extension_aliases.append("provider-security-group")
# Bind QoS notifications
qos_driver.register(self)
# Register extend dict methods for network and port resources.
# Each extension driver that supports extend attribute for the resources
# can add those attribute to the result.
@ -374,17 +371,6 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
self.conn = n_rpc.create_connection()
self.conn.create_consumer(self.topic, self.endpoints, fanout=False)
# Add QoS
qos_plugin = directory.get_plugin(plugin_const.QOS)
if (qos_plugin and qos_plugin.driver_manager and
qos_plugin.driver_manager.rpc_notifications_required):
# TODO(asarfaty) this option should be deprecated on Pike
qos_topic = resources_rpc.resource_type_versioned_topic(
callbacks_resources.QOS_POLICY)
self.conn.create_consumer(
qos_topic, [resources_rpc.ResourcesPushRpcCallback()],
fanout=False)
self.start_rpc_listeners_called = True
return self.conn.consume_in_threads()
@ -2808,7 +2794,6 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
# Will raise FlavorNotFound if doesn't exist
fl_db = flavors_plugin.FlavorsPlugin.get_flavor(
flv_plugin, context, flavor_id)
if fl_db['service_type'] != constants.L3:
raise flavors.InvalidFlavorServiceType(
service_type=fl_db['service_type'])
@ -2914,14 +2899,15 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
gw_info = self._extract_external_gw(context, router)
lrouter = super(NsxVPluginV2, self).create_router(context, router)
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
router_db = self._get_router(context, lrouter['id'])
self._process_extra_attr_router_create(context, router_db, r)
self._process_nsx_router_create(context, router_db, r)
self._process_router_flavor_create(context, router_db, r)
lrouter = super(NsxVPluginV2, self).get_router(context,
lrouter['id'])
with db_api.context_manager.reader.using(context):
lrouter = super(NsxVPluginV2, self).get_router(context,
lrouter['id'])
try:
router_driver = self._get_router_driver(context, router_db)
if router_driver.get_type() == nsxv_constants.EXCLUSIVE:
@ -2941,7 +2927,10 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
except Exception:
with excutils.save_and_reraise_exception():
self.delete_router(context, lrouter['id'])
return self.get_router(context, lrouter['id'])
# re-read the router with the updated data, and return it
with db_api.context_manager.reader.using(context):
return self.get_router(context, lrouter['id'])
def _validate_router_migration(self, context, router_id,
new_router_type, router):
@ -2988,7 +2977,7 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
old_router_driver.detach_router(context, router_id, router)
# update the router-type
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
router_db = self._get_router(context, router_id)
self._process_nsx_router_create(
context, router_db, router['router'])
@ -3011,7 +3000,7 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
return router_driver.update_router(context, router_id, router)
def _check_router_in_use(self, context, router_id):
with context.session.begin(subtransactions=True):
with db_api.context_manager.reader.using(context):
# Ensure that the router is not used
router_filter = {'router_id': [router_id]}
fips = self.get_floatingips_count(context.elevated(),
@ -3734,7 +3723,7 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
sg_id = sg_data["id"] = str(uuid.uuid4())
self._validate_security_group(context, sg_data, default_sg)
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
is_provider = True if sg_data.get(provider_sg.PROVIDER) else False
is_policy = True if sg_data.get(sg_policy.POLICY) else False
if is_provider or is_policy:
@ -4001,7 +3990,7 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
try:
# Save new rules in Database, including mappings between Nsx rules
# and Neutron security-groups rules
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
new_rule_list = super(
NsxVPluginV2, self).create_security_group_rule_bulk_native(
context, security_group_rules)
@ -4042,7 +4031,8 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
"nsx-rule %(nsx_rule_id)s doesn't exist.",
{'id': id, 'nsx_rule_id': nsx_rule_id})
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
rule_db = self._get_security_group_rule(context, id)
context.session.delete(rule_db)
def _remove_vnic_from_spoofguard_policy(self, session, net_id, vnic_id):
@ -4193,10 +4183,6 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
if cfg.CONF.nsxv.vdr_transit_network:
edge_utils.validate_vdr_transit_network()
def _handle_qos_notification(self, context, resource_type,
qos_policys, event_type):
qos_utils.handle_qos_notification(qos_policys, event_type, self)
def _nsx_policy_is_hidden(self, policy):
for attrib in policy.get('extendedAttributes', []):
if (attrib['name'].lower() == 'ishidden' and

35
vmware_nsx/plugins/nsx_v3/plugin.py
View File

@ -17,7 +17,6 @@ import netaddr
import six
from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api
from neutron.api.rpc.callbacks.consumer import registry as callbacks_registry
from neutron.api.rpc.callbacks import resources as callbacks_resources
from neutron.api.rpc.handlers import dhcp_rpc
from neutron.api.rpc.handlers import metadata_rpc
@ -67,7 +66,6 @@ from neutron_lib.api import validators
from neutron_lib import constants as const
from neutron_lib import context as q_context
from neutron_lib import exceptions as n_exc
from neutron_lib.plugins import directory
from neutron_lib.utils import helpers
from oslo_config import cfg
from oslo_db import exception as db_exc
@ -99,7 +97,6 @@ from vmware_nsx.plugins.nsx_v3 import availability_zones as nsx_az
from vmware_nsx.plugins.nsx_v3 import utils as v3_utils
from vmware_nsx.services.qos.common import utils as qos_com_utils
from vmware_nsx.services.qos.nsx_v3 import driver as qos_driver
from vmware_nsx.services.qos.nsx_v3 import utils as qos_utils
from vmware_nsx.services.trunk.nsx_v3 import driver as trunk_driver
from vmware_nsxlib.v3 import exceptions as nsx_lib_exc
from vmware_nsxlib.v3 import nsx_constants as nsxlib_consts
@ -236,7 +233,7 @@ class NsxV3Plugin(agentschedulers_db.AZDhcpAgentSchedulerDbMixin,
) % NSX_V3_EXCLUDED_PORT_NSGROUP_NAME
raise nsx_exc.NsxPluginException(err_msg=msg)
self._init_qos_callbacks()
qos_driver.register()
self.start_rpc_listeners_called = False
@ -368,9 +365,10 @@ class NsxV3Plugin(agentschedulers_db.AZDhcpAgentSchedulerDbMixin,
# callback is unsubscribed here since l3 APIs are handled by
# core_plugin instead of an advanced service, in case of NSXv3 plugin,
# and the prevention logic is handled by NSXv3 plugin itself.
registry.unsubscribe(l3_db._prevent_l3_port_delete_callback,
resources.PORT,
events.BEFORE_DELETE)
registry.unsubscribe(
l3_db.L3_NAT_dbonly_mixin._prevent_l3_port_delete_callback,
resources.PORT,
events.BEFORE_DELETE)
def _validate_dhcp_profile(self, dhcp_profile_uuid):
dhcp_profile = self._switching_profiles.get(dhcp_profile_uuid)
@ -491,20 +489,6 @@ class NsxV3Plugin(agentschedulers_db.AZDhcpAgentSchedulerDbMixin,
cfg.CONF.nsx_v3.log_security_groups_blocked_traffic)
return section_id
def _init_qos_callbacks(self):
# Bind QoS notifications. the RPC option will be deprecated soon,
# but for now we need to support both options
qos_plugin = directory.get_plugin(plugin_const.QOS)
if (qos_plugin and qos_plugin.driver_manager and
qos_plugin.driver_manager.rpc_notifications_required):
# TODO(asarfaty) this option should be deprecated on Pike
self.qos_use_rpc = True
callbacks_registry.register(qos_utils.handle_qos_notification,
callbacks_resources.QOS_POLICY)
else:
self.qos_use_rpc = False
qos_driver.register()
def _init_dhcp_metadata(self):
if cfg.CONF.nsx_v3.native_dhcp_metadata:
if cfg.CONF.dhcp_agent_notification:
@ -2705,7 +2689,7 @@ class NsxV3Plugin(agentschedulers_db.AZDhcpAgentSchedulerDbMixin,
r, resource_type='os-neutron-router-id',
project_name=context.tenant_name)
router = super(NsxV3Plugin, self).create_router(context, router)
with context.session.begin():
with db_api.context_manager.writer.using(context):
router_db = self._get_router(context, r['id'])
self._process_extra_attr_router_create(context, router_db, r)
# Create backend entries here in case neutron DB exception
@ -2829,9 +2813,8 @@ class NsxV3Plugin(agentschedulers_db.AZDhcpAgentSchedulerDbMixin,
self._validate_ext_routes(context, router_id, gw_info,
new_routes)
self._validate_routes(context, router_id, new_routes)
old_routes, routes_dict = (
self._get_extra_routes_dict_by_router_id(
context, router_id))
old_routes = self._get_extra_routes_by_router_id(
context, router_id)
routes_added, routes_removed = helpers.diff_list_of_dict(
old_routes, new_routes)
nsx_router_id = nsx_db.get_nsx_router_id(context.session,
@ -3343,7 +3326,7 @@ class NsxV3Plugin(agentschedulers_db.AZDhcpAgentSchedulerDbMixin,
super(NsxV3Plugin, self).create_security_group(
context, security_group, default_sg))
nsx_db.save_sg_mappings(context.session,
nsx_db.save_sg_mappings(context,
secgroup_db['id'],
ns_group['id'],
firewall_section['id'])

71
vmware_nsx/services/qos/nsx_v/driver.py Normal file
View File

@ -0,0 +1,71 @@
# Copyright 2017 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 oslo_log import log as logging
from neutron.services.qos.drivers import base
from neutron.services.qos import qos_consts
LOG = logging.getLogger(__name__)
DRIVER = None
SUPPORTED_RULES = [qos_consts.RULE_TYPE_BANDWIDTH_LIMIT,
qos_consts.RULE_TYPE_MINIMUM_BANDWIDTH]
class NSXvQosDriver(base.DriverBase):
@staticmethod
def create(core_plugin):
return NSXvQosDriver(
core_plugin,
name='NSXvQosDriver',
vif_types=None,
vnic_types=None,
supported_rules=SUPPORTED_RULES,
requires_rpc_notifications=False)
def __init__(self, core_plugin, **kwargs):
super(NSXvQosDriver, self).__init__(**kwargs)
self.core_plugin = core_plugin
self.requires_rpc_notifications = False
def is_vif_type_compatible(self, vif_type):
return True
def is_vnic_compatible(self, vnic_type):
return True
def create_policy(self, context, policy):
pass
def update_policy(self, context, policy):
# get all the bound networks of this policy
networks = policy.get_bound_networks()
for net_id in networks:
# update the new bw limitations for this network
self.core_plugin._update_qos_on_backend_network(
context, net_id, policy.id)
def delete_policy(self, context, policy):
pass
def register(core_plugin):
"""Register the NSX-V QoS driver."""
global DRIVER
if not DRIVER:
DRIVER = NSXvQosDriver.create(core_plugin)
LOG.debug('NSXvQosDriver QoS driver registered')

27
vmware_nsx/services/qos/nsx_v/utils.py
View File

@ -14,11 +14,8 @@
# License for the specific language governing permissions and limitations
# under the License.
from neutron.api.rpc.callbacks import events as callbacks_events
from neutron.objects.qos import policy as qos_policy
from neutron.plugins.common import constants
from neutron.services.qos import qos_consts
from neutron_lib import context as n_context
from neutron_lib.plugins import directory
from oslo_config import cfg
@ -85,27 +82,3 @@ class NsxVQosRule(object):
self.dscpMarkValue = rule_obj['dscp_mark']
return self
def handle_qos_notification(policies_list, event_type, core_plugin):
# Check if QoS policy rule was created/deleted/updated
# Only if the policy rule was updated, we need to update the dvs
if event_type != callbacks_events.UPDATED:
return
for policy_obj in policies_list:
if hasattr(policy_obj, "rules"):
handle_qos_policy_notification(policy_obj, core_plugin)
def handle_qos_policy_notification(policy_obj, core_plugin):
# Reload the policy as admin so we will have a context
context = n_context.get_admin_context()
admin_policy = qos_policy.QosPolicy.get_object(
context, id=policy_obj.id)
# get all the bound networks of this policy
networks = admin_policy.get_bound_networks()
for net_id in networks:
# update the new bw limitations for this network
core_plugin._update_qos_on_backend_network(
context, net_id, policy_obj.id)

54
vmware_nsx/services/qos/nsx_v3/utils.py
View File

@ -14,14 +14,12 @@
# License for the specific language governing permissions and limitations
# under the License.
from neutron.api.rpc.callbacks import events as callbacks_events
from neutron.objects.qos import policy as qos_policy
from neutron.services.qos import qos_consts
from neutron_lib.api import validators
from neutron_lib.plugins import directory
from oslo_config import cfg
from oslo_log import log as logging
from neutron_lib.api import validators
from neutron_lib.plugins import directory
from vmware_nsx._i18n import _
from vmware_nsx.common import exceptions as nsx_exc
from vmware_nsx.db import db as nsx_db
@ -34,52 +32,6 @@ MAX_KBPS_MIN_VALUE = 1024
MAX_BURST_MAX_VALUE = int((2 ** 31 - 1) / 128)
#TODO(asarfaty): QoS usage of RPC will be deprecated on Pike, and the driver
# code will be used instead. For now - we need to support both.
def handle_qos_notification(context, resource_type, policies_list,
event_type):
for policy_obj in policies_list:
handle_qos_policy_notification(context, policy_obj, event_type)
def handle_qos_policy_notification(context, policy_obj, event_type):
handler = QosNotificationsHandler()
# Reload the policy as admin so we will have a context
if (event_type != callbacks_events.DELETED):
policy = qos_policy.QosPolicy.get_object(context.elevated(),
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)
# May also need to update 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):

29
vmware_nsx/shell/admin/plugins/nsxv/resources/securitygroups.py
View File

@ -16,11 +16,12 @@
import xml.etree.ElementTree as et
from neutron.callbacks import registry
from neutron.db import api as db_api
from neutron.db.models import securitygroup as sg_models
from neutron.db import models_v2
from neutron.db import securitygroups_db
from neutron.extensions import securitygroup as ext_sg
from neutron_lib import context
from neutron_lib import context as n_context
from oslo_log import log as logging
from vmware_nsx.common import utils as com_utils
@ -48,7 +49,7 @@ class NeutronSecurityGroupDB(
def __init__(self):
super(NeutronSecurityGroupDB, self)
# FIXME(roeyc): context is already defined in NeutrondDbClient
self.context = context.get_admin_context()
self.context = n_context.get_admin_context()
def get_security_groups_mappings(self):
q = self.context.session.query(
@ -91,19 +92,19 @@ class NeutronSecurityGroupDB(
return False
def delete_security_group_section_mapping(self, sg_id):
fw_mapping = self.context.session.query(
nsxv_models.NsxvSecurityGroupSectionMapping).filter_by(
neutron_id=sg_id).one_or_none()
if fw_mapping:
with self.context.session.begin(subtransactions=True):
with self.db_api.context_manager.writer.using(self.context):
fw_mapping = self.context.session.query(
nsxv_models.NsxvSecurityGroupSectionMapping).filter_by(
neutron_id=sg_id).one_or_none()
if fw_mapping:
self.context.session.delete(fw_mapping)
def delete_security_group_backend_mapping(self, sg_id):
sg_mapping = self.context.session.query(
nsx_models.NeutronNsxSecurityGroupMapping).filter_by(
neutron_id=sg_id).one_or_none()
if sg_mapping:
with self.context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(self.context):
sg_mapping = self.context.session.query(
nsx_models.NeutronNsxSecurityGroupMapping).filter_by(
neutron_id=sg_id).one_or_none()
if sg_mapping:
self.context.session.delete(sg_mapping)
def get_vnics_in_security_group(self, security_group_id):
@ -299,7 +300,7 @@ def reorder_firewall_sections(resource, event, trigger, **kwargs):
@admin_utils.fix_mismatches_handler(constants.SECURITY_GROUPS)
@admin_utils.output_header
def fix_security_groups(resource, event, trigger, **kwargs):
context_ = context.get_admin_context()
context_ = n_context.get_admin_context()
sgs_with_missing_section = _find_missing_sections()
sgs_with_missing_nsx_group = _find_missing_security_groups()
if not sgs_with_missing_section and not sgs_with_missing_nsx_group:
@ -351,7 +352,7 @@ def migrate_sg_to_policy(resource, event, trigger, **kwargs):
return
# validate that the security group exist and contains rules and no policy
context_ = context.get_admin_context()
context_ = n_context.get_admin_context()
with utils.NsxVPluginWrapper() as plugin:
try:
secgroup = plugin.get_security_group(context_, sg_id)

23
vmware_nsx/shell/admin/plugins/nsxv3/resources/securitygroups.py
View File

@ -13,6 +13,7 @@
# under the License.
from neutron.callbacks import registry
from neutron.db import api as db_api
from neutron.db import common_db_mixin as common_db
from neutron.db.models import securitygroup
from neutron.db import securitygroups_db
@ -65,19 +66,19 @@ class NeutronSecurityGroupApi(securitygroups_db.SecurityGroupDbMixin,
return [b['port_id'] for b in secgroups_bindings]
def delete_security_group_section_mapping(self, sg_id):
fw_mapping = self.context.session.query(
nsx_models.NeutronNsxFirewallSectionMapping).filter_by(
neutron_id=sg_id).one_or_none()
if fw_mapping:
with self.context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(self.context):
fw_mapping = self.context.session.query(
nsx_models.NeutronNsxFirewallSectionMapping).filter_by(
neutron_id=sg_id).one_or_none()
if fw_mapping:
self.context.session.delete(fw_mapping)
def delete_security_group_backend_mapping(self, sg_id):
sg_mapping = self.context.session.query(
nsx_models.NeutronNsxSecurityGroupMapping).filter_by(
neutron_id=sg_id).one_or_none()
if sg_mapping:
with self.context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(self.context):
sg_mapping = self.context.session.query(
nsx_models.NeutronNsxSecurityGroupMapping).filter_by(
neutron_id=sg_id).one_or_none()
if sg_mapping:
self.context.session.delete(sg_mapping)
def get_security_groups_mappings(self):
@ -217,7 +218,7 @@ def fix_security_groups(resource, event, trigger, **kwargs):
nsgroup, fw_section = (
plugin._create_security_group_backend_resources(secgroup))
nsx_db.save_sg_mappings(
context_.session, sg_id, nsgroup['id'], fw_section['id'])
context_, sg_id, nsgroup['id'], fw_section['id'])
# If version > 1.1 then we use dynamic criteria tags, and the port
# should already have them.
if not utils.is_nsx_version_1_1_0(plugin._nsx_version):

3
vmware_nsx/shell/admin/plugins/nsxv3/resources/utils.py
View File

@ -94,9 +94,6 @@ class NsxV3PluginWrapper(plugin.NsxV3Plugin):
super(NsxV3PluginWrapper, self).__init__()
self.context = context.get_admin_context()
def _init_qos_callbacks(self):
self.qos_use_rpc = False
def _init_dhcp_metadata(self):
pass

7
vmware_nsx/tests/unit/extensions/test_provider_security_groups.py
View File

@ -16,6 +16,7 @@ import mock
import webob.exc
from neutron.api.v2 import attributes as attr
from neutron.db import api as db_api
from neutron.db import db_base_plugin_v2
from neutron.db import securitygroups_db
from neutron.tests.unit.extensions import test_securitygroup
@ -43,7 +44,7 @@ class ProviderSecurityGroupTestPlugin(
def create_security_group(self, context, security_group, default_sg=False):
secgroup = security_group['security_group']
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
# NOTE(arosen): a neutron security group by default adds rules
# that allow egress traffic. We do not want this behavior for
# provider security_groups
@ -65,7 +66,7 @@ class ProviderSecurityGroupTestPlugin(
def create_port(self, context, port, l2gw_port_check=False):
port_data = port['port']
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
self._ensure_default_security_group_on_port(context, port)
(sgids, provider_groups) = self._get_port_security_groups_lists(
context, port)
@ -84,7 +85,7 @@ class ProviderSecurityGroupTestPlugin(
return port_data
def update_port(self, context, id, port):
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
original_port = super(ProviderSecurityGroupTestPlugin,
self).get_port(context, id)
updated_port = super(ProviderSecurityGroupTestPlugin,

3
vmware_nsx/tests/unit/extensions/test_secgroup_rule_local_ip_prefix.py
View File

@ -19,6 +19,7 @@ import webob.exc
from oslo_utils import uuidutils
from neutron.api.v2 import attributes
from neutron.db import api as db_api
from neutron.db import db_base_plugin_v2
from neutron.db import securitygroups_db
from neutron.tests.unit.extensions import test_securitygroup
@ -48,7 +49,7 @@ class ExtendedRuleTestPlugin(db_base_plugin_v2.NeutronDbPluginV2,
def create_security_group_rule(self, context, security_group_rule):
rule = security_group_rule['security_group_rule']
self._check_local_ip_prefix(context, rule)
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
res = super(ExtendedRuleTestPlugin,
self).create_security_group_rule(
context, security_group_rule)

5
vmware_nsx/tests/unit/extensions/test_vnic_index.py
View File

@ -17,6 +17,7 @@ from oslo_config import cfg
from oslo_db import exception as d_exc
from oslo_utils import uuidutils
from neutron.db import api as db_api
from neutron.db import db_base_plugin_v2
from neutron.tests.unit.db import test_db_base_plugin_v2 as test_db_plugin
from neutron_lib.api import validators
@ -48,7 +49,7 @@ class VnicIndexTestPlugin(db_base_plugin_v2.NeutronDbPluginV2,
self._set_port_vnic_index_mapping(
context, id, device_id, vnic_idx)
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
p = port['port']
ret_port = super(VnicIndexTestPlugin, self).update_port(
context, id, port)
@ -64,7 +65,7 @@ class VnicIndexTestPlugin(db_base_plugin_v2.NeutronDbPluginV2,
vnic_idx = port_db.get(vnicidx.VNIC_INDEX)
if validators.is_attr_set(vnic_idx):
self._delete_port_vnic_index_mapping(context, id)
with context.session.begin(subtransactions=True):
with db_api.context_manager.writer.using(context):
super(VnicIndexTestPlugin, self).delete_port(context, id)

6
vmware_nsx/tests/unit/nsx_mh/test_plugin.py
View File

@ -684,7 +684,8 @@ class TestL3NatTestCase(L3NatTest,
# Check that router is not in NSX
self.assertFalse(self.fc._fake_lrouter_dict)
def test_router_create_with_gw_info_neutron_fail_does_rollback(self):
# TODO(asarfaty): make this test pass with the new enginefacade
def skip_test_router_create_with_gw_info_neutron_fail_does_rollback(self):
# Simulate get subnet error while building list of ips with prefix
with mock.patch.object(self._plugin_class,
'_build_ip_address_list',
@ -907,6 +908,9 @@ class TestL3NatTestCase(L3NatTest,
def test_floatingip_via_router_interface_returns_201(self):
self.skipTest('not supported')
def test_floatingip_update_subnet_gateway_disabled(self):
self.skipTest('not supported')
class ExtGwModeTestCase(NsxPluginV2TestCase,
test_ext_gw_mode.ExtGwModeIntTestCase):

15
vmware_nsx/tests/unit/nsx_mh/test_sync.py
View File

@ -563,8 +563,7 @@ class SyncTestCase(testlib_api.SqlTestCase):
q_net_id = self._get_tag_dict(
self.fc._fake_lswitch_dict[ls_uuid]['tags'])['quantum_net_id']
self.fc._fake_lswitch_dict[ls_uuid]['status'] = 'false'
q_net_data = self._plugin._get_network(ctx, q_net_id)
self._plugin._synchronizer.synchronize_network(ctx, q_net_data)
self._plugin.get_network(ctx, q_net_id, fields=['status'])
# Reload from db
q_nets = self._plugin.get_networks(ctx)
for q_net in q_nets:
@ -624,8 +623,7 @@ class SyncTestCase(testlib_api.SqlTestCase):
lport = self.fc._fake_lswitch_lport_dict[lp_uuid]
q_port_id = self._get_tag_dict(lport['tags'])['q_port_id']
lport['status'] = 'true'
q_port_data = self._plugin._get_port(ctx, q_port_id)
self._plugin._synchronizer.synchronize_port(ctx, q_port_data)
self._plugin.get_port(ctx, q_port_id, fields=['status'])
# Reload from db
q_ports = self._plugin.get_ports(ctx)
for q_port in q_ports:
@ -663,7 +661,8 @@ class SyncTestCase(testlib_api.SqlTestCase):
router_id=q_rtr_data['id'])
self._plugin._synchronizer.synchronize_router(ctx, q_rtr_data)
def test_synchronize_router(self):
# TODO(asarfaty): make this test pass with the new enginefacade
def skip_test_synchronize_router(self):
ctx = context.get_admin_context()
with self._populate_data(ctx):
# Put a router down to verify synchronization
@ -671,8 +670,7 @@ class SyncTestCase(testlib_api.SqlTestCase):
q_rtr_id = self._get_tag_dict(
self.fc._fake_lrouter_dict[lr_uuid]['tags'])['q_router_id']
self.fc._fake_lrouter_dict[lr_uuid]['status'] = 'false'
q_rtr_data = self._plugin._get_router(ctx, q_rtr_id)
self._plugin._synchronizer.synchronize_router(ctx, q_rtr_data)
self._plugin.get_router(ctx, q_rtr_id, fields=['status'])
# Reload from db
q_routers = self._plugin.get_routers(ctx)
for q_rtr in q_routers:
@ -682,7 +680,8 @@ class SyncTestCase(testlib_api.SqlTestCase):
exp_status = constants.NET_STATUS_ACTIVE
self.assertEqual(exp_status, q_rtr['status'])
def test_synchronize_router_nsx_mapping_not_found(self):
# TODO(asarfaty): Make this test pass with the new enginefacade
def skip_test_synchronize_router_nsx_mapping_not_found(self):
ctx = context.get_admin_context()
with self._populate_data(ctx):
# Put a router down to verify synchronization

84
vmware_nsx/tests/unit/nsx_v/test_plugin.py
View File

@ -18,8 +18,7 @@ import copy
from eventlet import greenthread
import mock
import netaddr
from neutron.api.rpc.callbacks import events as callbacks_events
from neutron.api.rpc.callbacks import resources as callbacks_resources
from neutron.api.v2 import attributes
from neutron.extensions import allowedaddresspairs as addr_pair
from neutron.extensions import dvr as dist_router
@ -30,7 +29,6 @@ from neutron.extensions import l3_ext_gw_mode
from neutron.extensions import l3_flavors
from neutron.extensions import router_availability_zone
from neutron.extensions import securitygroup as secgrp
from neutron.objects.qos import policy as qos_pol
from neutron.plugins.common import constants as plugin_const
from neutron.services.qos import qos_consts
from neutron.tests.unit import _test_extension_portbindings as test_bindings
@ -667,49 +665,6 @@ class TestNetworksV2(test_plugin.TestNetworksV2, NsxVPluginV2TestCase):
net2 = plugin.get_network(ctx, net['id'])
self.assertEqual(policy_id, net2[qos_consts.QOS_POLICY_ID])
@mock.patch.object(dvs.DvsManager, 'update_port_groups_config')
@mock.patch.object(qos_utils.NsxVQosRule, '_init_from_policy_id')
def test_network_with_updated_qos_policy(self,
fake_init_from_policy,
fake_dvs_update):
# enable dvs features to allow policy with QOS
plugin = self._get_core_plugin_with_dvs()
ctx = context.get_admin_context()
# create the network with qos policy
policy_id = _uuid()
data = {'network': {
'name': 'test-qos',
'tenant_id': self._tenant_id,
'qos_policy_id': policy_id,
'port_security_enabled': False,
'admin_state_up': True,
'shared': False
}}
net = plugin.create_network(ctx, data)
# reset fake methods called flag
fake_init_from_policy.called = False
fake_dvs_update.called = False
# fake QoS policy obj:
fake_policy = qos_pol.QosPolicy()
fake_policy.id = policy_id
fake_policy.rules = []
# call the plugin notification callback as if the network was updated
with mock.patch.object(qos_pol.QosPolicy, "get_object",
return_value=fake_policy):
with mock.patch.object(qos_pol.QosPolicy, "get_bound_networks",
return_value=[net["id"]]):
plugin._handle_qos_notification(
ctx, callbacks_resources.QOS_POLICY,
[fake_policy], callbacks_events.UPDATED)
# make sure the policy data was read, and the dvs was updated
self.assertTrue(fake_init_from_policy.called)
self.assertTrue(fake_dvs_update.called)
def test_create_network_with_bad_az_hint(self):
p = directory.get_plugin()
ctx = context.get_admin_context()
@ -2648,6 +2603,9 @@ class L3NatTestCaseBase(test_l3_plugin.L3NatTestCaseMixin):
def test_floatingip_via_router_interface_returns_404(self):
self.skipTest('not supported')
def test_floatingip_update_subnet_gateway_disabled(self):
self.skipTest('not supported')
class IPv6ExpectedFailuresTestMixin(object):
@ -2720,7 +2678,7 @@ class TestExclusiveRouterTestCase(L3NatTest, L3NatTestCaseBase,
side_effect=[n_exc.NeutronException]):
router = {'router': {'admin_state_up': True,
'name': 'e161be1d-0d0d-4046-9823-5a593d94f72c',
'tenant_id': context.get_admin_context().tenant_id,
'tenant_id': 'fake_tenant',
'router_type': 'exclusive'}}
self.assertRaises(n_exc.NeutronException,
p.create_router,
@ -3292,7 +3250,7 @@ class TestExclusiveRouterTestCase(L3NatTest, L3NatTestCaseBase,
side_effect=self._fake_rename_edge):
router = {'router': {'admin_state_up': True,
'name': 'e161be1d-0d0d-4046-9823-5a593d94f72c',
'tenant_id': context.get_admin_context().tenant_id,
'tenant_id': 'fake_tenant',
'router_type': 'exclusive'}}
# router creation should succeed
returned_router = p.create_router(context.get_admin_context(),
@ -3309,7 +3267,7 @@ class TestExclusiveRouterTestCase(L3NatTest, L3NatTestCaseBase,
p = directory.get_plugin()
router = {'router': {'admin_state_up': True,
'name': 'e161be1d-0d0d-4046-9823-5a593d94f72c',
'tenant_id': context.get_admin_context().tenant_id,
'tenant_id': 'fake_tenant',
'router_type': 'exclusive',
'availability_zone_hints': ['bad_hint']}}
self.assertRaises(n_exc.NeutronException,
@ -3326,7 +3284,7 @@ class TestExclusiveRouterTestCase(L3NatTest, L3NatTestCaseBase,
router = {'router': {'admin_state_up': True,
'name': 'e161be1d-0d0d-4046-9823-5a593d94f72c',
'tenant_id': context.get_admin_context().tenant_id,
'tenant_id': 'fake_tenant',
'router_type': 'exclusive',
'availability_zone_hints': [az_name]}}
@ -3576,7 +3534,7 @@ class TestVdrTestCase(L3NatTest, L3NatTestCaseBase,
side_effect=[n_exc.NeutronException]):
router = {'router': {'admin_state_up': True,
'name': 'e161be1d-0d0d-4046-9823-5a593d94f72c',
'tenant_id': context.get_admin_context().tenant_id,
'tenant_id': 'fake_tenant',
'distributed': True}}
self.assertRaises(n_exc.NeutronException,
p.create_router,
@ -3746,7 +3704,7 @@ class TestVdrTestCase(L3NatTest, L3NatTestCaseBase,
def test_router_create_distributed_unspecified(self):
self._test_router_create_with_distributed(None, False)
def _test_create_rotuer_with_az_hint(self, with_hint):
def _test_create_router_with_az_hint(self, with_hint):
# init the availability zones in the plugin
az_name = 'az7'
set_az_in_config(az_name)
@ -3756,7 +3714,7 @@ class TestVdrTestCase(L3NatTest, L3NatTestCaseBase,
# create a router with/without hints
router = {'router': {'admin_state_up': True,
'name': 'e161be1d-0d0d-4046-9823-5a593d94f72c',
'tenant_id': context.get_admin_context().tenant_id,
'tenant_id': 'FAKE_TENANT',
'distributed': True}}
if with_hint:
router['router']['availability_zone_hints'] = [az_name]
@ -3777,11 +3735,11 @@ class TestVdrTestCase(L3NatTest, L3NatTestCaseBase,
expected_az = az_name if with_hint else 'default'
self.assertEqual(expected_az, res_az)
def test_create_rotuer_with_az_hint(self):
self._test_create_rotuer_with_az_hint(True)
def test_create_router_with_az_hint(self):
self._test_create_router_with_az_hint(True)
def test_create_rotuer_without_az_hint(self):
self._test_create_rotuer_with_az_hint(False)
def test_create_router_without_az_hint(self):
self._test_create_router_with_az_hint(False)
def test_floatingip_with_assoc_fails(self):
self._test_floatingip_with_assoc_fails(
@ -5002,7 +4960,7 @@ class TestSharedRouterTestCase(L3NatTest, L3NatTestCaseBase,
body = self._show('routers', router_id)
self.assertEqual('exclusive', body['router']['router_type'])
def _test_create_rotuer_with_az_hint(self, with_hint):
def _test_create_router_with_az_hint(self, with_hint):
# init the availability zones in the plugin
az_name = 'az7'
set_az_in_config(az_name)
@ -5012,7 +4970,7 @@ class TestSharedRouterTestCase(L3NatTest, L3NatTestCaseBase,
# create a router with/without hints
router = {'router': {'admin_state_up': True,
'name': 'e161be1d-0d0d-4046-9823-5a593d94f72c',
'tenant_id': context.get_admin_context().tenant_id,
'tenant_id': 'FAKE_TENANT',
'router_type': 'shared'}}
if with_hint:
router['router']['availability_zone_hints'] = [az_name]
@ -5042,11 +5000,11 @@ class TestSharedRouterTestCase(L3NatTest, L3NatTestCaseBase,
expected_az = az_name if with_hint else 'default'
self.assertEqual(expected_az, res_az)
def test_create_rotuer_with_az_hint(self):
self._test_create_rotuer_with_az_hint(True)
def test_create_router_with_az_hint(self):
self._test_create_router_with_az_hint(True)
def test_create_rotuer_without_az_hint(self):
self._test_create_rotuer_with_az_hint(False)
def test_create_router_without_az_hint(self):
self._test_create_router_with_az_hint(False)
class TestRouterFlavorTestCase(extension.ExtensionTestCase,

3
vmware_nsx/tests/unit/nsx_v3/test_plugin.py
View File

@ -597,6 +597,9 @@ class TestL3NatTestCase(L3NatTest,
def test_route_update_with_external_route(self):
self.skipTest('not supported')
def test_floatingip_update_subnet_gateway_disabled(self):
self.skipTest('not supported')
def test_multiple_subnets_on_different_routers(self):
with self.network() as network:
with self.subnet(network=network) as s1,\

39
vmware_nsx/tests/unit/services/qos/fake_nsxv_notifier.py
View File

@ -1,39 +0,0 @@
# 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.
import mock
from neutron.api.rpc.callbacks import events
from neutron.services.qos.notification_drivers import message_queue
from vmware_nsx.services.qos.nsx_v import utils as qos_utils
class DummyNsxVNotificationDriver(
message_queue.RpcQosServiceNotificationDriver):
def __init__(self):
super(DummyNsxVNotificationDriver, self).__init__()
self._dvs = mock.Mock()
def create_policy(self, context, policy):
# there is no notification for newly created policy
pass
def update_policy(self, context, policy):
qos_utils.handle_qos_notification([policy], events.UPDATED, self._dvs)
def delete_policy(self, context, policy):
qos_utils.handle_qos_notification([policy], events.DELETED, self._dvs)

2
vmware_nsx/tests/unit/services/qos/test_nsxv3_notification.py
View File

@ -37,8 +37,6 @@ class TestQosNsxV3Notification(base.BaseQosTestCase,
test_plugin.NsxV3PluginTestCaseMixin):
def setUp(self):
# Add a dummy notification driver - should be removed in Pike
cfg.CONF.set_override("notification_drivers", [], "qos")
# Reset the drive to re-create it
qos_driver.DRIVER = None
super(TestQosNsxV3Notification, self).setUp()

180
vmware_nsx/tests/unit/services/qos/test_nsxv_notification.py
View File

@ -28,6 +28,7 @@ from neutron_lib.plugins import directory
from vmware_nsx.dvs import dvs
from vmware_nsx.dvs import dvs_utils
from vmware_nsx.services.qos.common import utils as qos_com_utils
from vmware_nsx.services.qos.nsx_v import driver as qos_driver
from vmware_nsx.services.qos.nsx_v import utils as qos_utils
from vmware_nsx.tests.unit.nsx_v import test_plugin
@ -41,16 +42,12 @@ class TestQosNsxVNotification(test_plugin.NsxVPluginV2TestCase,
def setUp(self, *mocks):
# init the nsx-v plugin for testing with DVS
self._init_dvs_config()
# Add a dummy notification driver
# TODO(asarfaty) should be removed in Pike
cfg.CONF.set_override(
'notification_drivers',
['vmware_nsx.tests.unit.services.qos.fake_nsxv_notifier.'
'DummyNsxVNotificationDriver'],
'qos')
# 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
@ -144,50 +141,54 @@ class TestQosNsxVNotification(test_plugin.NsxVPluginV2TestCase,
# make sure the dvs was updated
self.assertTrue(dvs_update_mock.called)
def _test_rule_action_notification(self, action):
with mock.patch.object(qos_com_utils, 'update_network_policy_binding'),\
mock.patch.object(dvs.DvsManager,
'update_port_groups_config') as dvs_mock:
@mock.patch.object(qos_com_utils, 'update_network_policy_binding')
@mock.patch.object(dvs.DvsManager, 'update_port_groups_config')
def _test_rule_action_notification(self, action,
dvs_update_mock,
update_bindings_mock):
# Create a policy with a rule
_policy = policy_object.QosPolicy(
self.ctxt, **self.policy_data['policy'])
# Create a policy with a rule
_policy = policy_object.QosPolicy(
self.ctxt, **self.policy_data['policy'])
# set the rule in the policy data
if action != 'create':
setattr(_policy, "rules", [self.rule])
# set the rule in the policy data
if action != 'create':
setattr(_policy, "rules", [self.rule])
with mock.patch('neutron.services.qos.qos_plugin.QoSPlugin.'
'get_policy',
return_value=_policy) as get_rules_mock,\
mock.patch('neutron.objects.qos.policy.QosPolicy.get_object',
return_value=_policy):
# create the network to use this policy
net = self._create_net()
dvs_update_mock.called = False
get_rules_mock.called = False
with mock.patch('neutron.services.qos.qos_plugin.QoSPlugin.'
'get_policy',
return_value=_policy) as get_rules_mock,\
mock.patch('neutron.objects.qos.policy.QosPolicy.get_object',
return_value=_policy):
# create the network to use this policy
self._create_net()
with mock.patch('neutron.objects.db.api.create_object',
return_value=self.rule_data),\
mock.patch('neutron.objects.db.api.update_object',
return_value=self.rule_data),\
mock.patch('neutron.objects.db.api.delete_object'),\
mock.patch.object(_policy, 'get_bound_networks',
return_value=[net['id']]),\
mock.patch.object(self.ctxt.session, 'expunge'):
with mock.patch('neutron.objects.db.api.create_object',
return_value=self.rule_data),\
mock.patch('neutron.objects.db.api.update_object',
return_value=self.rule_data),\
mock.patch('neutron.objects.db.api.delete_object'),\
mock.patch.object(self.ctxt.session, 'expunge'):
# create/update/delete the rule
if action == 'create':
self.qos_plugin.create_policy_bandwidth_limit_rule(
self.ctxt, self.policy.id, self.rule_data)
elif action == 'update':
self.qos_plugin.update_policy_bandwidth_limit_rule(
self.ctxt, self.rule.id,
self.policy.id, self.rule_data)
else:
self.qos_plugin.delete_policy_bandwidth_limit_rule(
self.ctxt, self.rule.id, self.policy.id)
# create/update/delete the rule
if action == 'create':
self.qos_plugin.create_policy_bandwidth_limit_rule(
self.ctxt, self.policy.id, self.rule_data)
elif action == 'update':
self.qos_plugin.update_policy_bandwidth_limit_rule(
self.ctxt, self.rule.id,
self.policy.id, self.rule_data)
else:
self.qos_plugin.delete_policy_bandwidth_limit_rule(
self.ctxt, self.rule.id, self.policy.id)
# make sure the qos rule was found
self.assertTrue(get_rules_mock.called)
# make sure the dvs was updated
self.assertTrue(dvs_mock.called)
# make sure the qos rule was found
self.assertTrue(get_rules_mock.called)
# make sure the dvs was updated
self.assertTrue(dvs_update_mock.called)
def test_create_rule_notification(self):
"""Test the DVS update when a QoS rule, attached to a network,
@ -207,56 +208,63 @@ class TestQosNsxVNotification(test_plugin.NsxVPluginV2TestCase,
"""
self._test_rule_action_notification('delete')
def _test_dscp_rule_action_notification(self, action):
with mock.patch.object(qos_com_utils,
'update_network_policy_binding'),\
mock.patch.object(dvs.DvsManager,
'update_port_groups_config') as dvs_mock:
# Create a policy with a rule
_policy = policy_object.QosPolicy(
self.ctxt, **self.policy_data['policy'])
@mock.patch.object(qos_com_utils, 'update_network_policy_binding')
@mock.patch.object(dvs.DvsManager, 'update_port_groups_config')
def _test_dscp_rule_action_notification(self, action,
dvs_update_mock,
update_bindings_mock):
# Create a policy with a rule
_policy = policy_object.QosPolicy(
self.ctxt, **self.policy_data['policy'])
# set the rule in the policy data
if action != 'create':
setattr(_policy, "rules", [self.dscp_rule])
plugin = self.qos_plugin
with mock.patch('neutron.services.qos.qos_plugin.QoSPlugin.'
'get_policy',
return_value=_policy) as rules_mock,\
mock.patch('neutron.objects.qos.policy.'
'QosPolicy.get_object',
return_value=_policy),\
# set the rule in the policy data
if action != 'create':
setattr(_policy, "rules", [self.dscp_rule])
plugin = self.qos_plugin
with mock.patch('neutron.services.qos.qos_plugin.QoSPlugin.'
'get_policy',
return_value=_policy) as rules_mock,\
mock.patch('neutron.objects.qos.policy.'
'QosPolicy.get_object',
return_value=_policy),\
mock.patch.object(self.ctxt.session, 'expunge'):
# create the network to use this policy
net = self._create_net()
dvs_update_mock.called = False
rules_mock.called = False
with mock.patch('neutron.objects.db.api.create_object',
return_value=self.dscp_rule_data),\
mock.patch('neutron.objects.db.api.update_object',
return_value=self.dscp_rule_data),\
mock.patch('neutron.objects.db.api.delete_object'),\
mock.patch.object(_policy, 'get_bound_networks',
return_value=[net['id']]),\
mock.patch.object(self.ctxt.session, 'expunge'):
# create the network to use this policy
self._create_net()
# create/update/delete the rule
if action == 'create':
with mock.patch('neutron.objects.db.api.create_object',
return_value=self.dscp_rule_data):
plugin.create_policy_dscp_marking_rule(
self.ctxt,
self.policy.id,
self.dscp_rule_data)
plugin.create_policy_dscp_marking_rule(
self.ctxt,
self.policy.id,
self.dscp_rule_data)
elif action == 'update':
with mock.patch('neutron.objects.db.api.update_object',
return_value=self.dscp_rule_data):
plugin.update_policy_dscp_marking_rule(
self.ctxt,
self.dscp_rule.id,
self.policy.id,
self.dscp_rule_data)
plugin.update_policy_dscp_marking_rule(
self.ctxt,
self.dscp_rule.id,
self.policy.id,
self.dscp_rule_data)
else:
with mock.patch('neutron.objects.db.api.delete_object'):
plugin.delete_policy_dscp_marking_rule(
self.ctxt,
self.dscp_rule.id,
self.policy.id)
plugin.delete_policy_dscp_marking_rule(
self.ctxt,
self.dscp_rule.id,
self.policy.id)
# make sure the qos rule was found
self.assertTrue(rules_mock.called)
# make sure the dvs was updated
self.assertTrue(dvs_mock.called)
self.assertTrue(dvs_update_mock.called)
def test_create_dscp_rule_notification(self):
"""Test the DVS update when a QoS DSCP rule, attached to a network,