x/vmware-nsx
Code Issues Proposed changes

Merge "NSX|V+V3: Octavia driver"

Browse Source
This commit is contained in:
Zuul 2018-10-07 09:25:57 +00:00 committed by Gerrit Code Review
commit 2dea64def5
36 changed files with 2090 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.zuul.yaml
View File

@ -158,3 +158,4 @@
- openstack/neutron-dynamic-routing
- openstack/neutron-vpnaas
- openstack/tap-as-a-service
- openstack/octavia

2
devstack/lib/nsx_common
View File

@ -30,7 +30,7 @@ function _nsxv_ini_set {
}
function install_neutron_projects {
pkg_list="networking-l2gw networking-sfc neutron-lbaas neutron-fwaas neutron-dynamic-routing neutron-vpnaas vmware-nsxlib"
pkg_list="networking-l2gw networking-sfc neutron-lbaas neutron-fwaas neutron-dynamic-routing neutron-vpnaas octavia vmware-nsxlib"
for pkg in `echo $pkg_list`
do
if is_plugin_enabled $pkg; then

24
doc/source/devstack.rst
View File

@ -238,6 +238,30 @@ Add neutron-vpnaas repo as an external repository and configure following flags
[DEFAULT]
api_extensions_path = $DEST/neutron-vpnaas/neutron_vpnaas/extensions
Octavia
~~~~~~~
Add octavia repo as an external repository and configure following flags in ``local.conf``::
[[local|localrc]]
OCTAVIA_NODE=api
DISABLE_AMP_IMAGE_BUILD=True
enable_plugin octavia $GIT_BASE/openstack/octavia.git
enable_plugin octavia-dashboard $GIT_BASE/openstack/octavia-dashboard
enable_service octavia
enable_service o-api
[[post-config|$OCTAVIA_CONF]]
[DEFAULT]
verbose = True
debug = True
[api_settings]
default_provider_driver=vmwareedge
enabled_provider_drivers=vmwareedge:NSX
[oslo_messaging]
topic=vmwarensxv_edge_lb
NSX-TVD
-------

1
lower-constraints.txt
View File

@ -55,6 +55,7 @@ munch==2.1.0
netaddr==0.7.18
netifaces==0.10.4
neutron-lib==1.18.0
octavia==3.0.0
openstackdocstheme==1.18.1
openstacksdk==0.11.2
os-client-config==1.28.0

6
releasenotes/notes/octavia-support-2fa83d464dbc4e52.yaml Normal file
View File

@ -0,0 +1,6 @@
---
prelude: >
Support Octavia loadbalancer support in NSXv and NSXv3 plugins.
features:
- |
NSXv and NSXv3 plugins now support Octavia loadbalancer.

1
requirements.txt
View File

@ -38,6 +38,7 @@ neutron-fwaas>=12.0.0 # Apache-2.0
neutron-vpnaas>=12.0.0 # Apache-2.0
neutron-dynamic-routing>=12.0.0 # Apache-2.0
vmware-nsxlib>=12.0.0 # Apache-2.0
#octavia>=3.0.0 # Apache-2.0
# The comment below indicates this project repo is current with neutron-lib
# and should receive neutron-lib consumption patches as they are released

3
setup.cfg
View File

@ -94,7 +94,8 @@ vmware_nsx.neutron.nsxv3.housekeeper.jobs =
orphaned_logical_router = vmware_nsx.plugins.nsx_v3.housekeeper.orphaned_logical_router:OrphanedLogicalRouterJob
orphaned_firewall_section = vmware_nsx.plugins.nsx_v3.housekeeper.orphaned_firewall_section:OrphanedFirewallSectionJob
mismatch_logical_port = vmware_nsx.plugins.nsx_v3.housekeeper.mismatch_logical_port:MismatchLogicalportJob
octavia.api.drivers =
vmwareedge = vmware_nsx.services.lbaas.octavia.octavia_driver:NSXOctaviaDriver
[build_sphinx]
source-dir = doc/source
build-dir = doc/build

1
tox.ini
View File

@ -34,6 +34,7 @@ commands =
pip install -q -e "git+https://git.openstack.org/openstack/neutron-fwaas#egg=neutron_fwaas"
pip install -q -e "git+https://git.openstack.org/openstack/neutron-dynamic-routing#egg=neutron_dynamic_routing"
pip install -q -e "git+https://git.openstack.org/openstack/neutron-vpnaas#egg=neutron_vpnaas"
pip install -q -e "git+https://git.openstack.org/openstack/octavia#egg=octavia"
pip install -q -e "git+https://git.openstack.org/openstack/vmware-nsxlib#egg=vmware_nsxlib"
pip install -q -e "git+https://git.openstack.org/openstack/neutron#egg=neutron"

4
vmware_nsx/common/config.py
View File

@ -262,6 +262,10 @@ nsx_common_opts = [
default=[],
help=_("(Optional) List of email addresses for "
"notifications.")),
cfg.IntOpt('octavia_stats_interval',
default=10,
help=_("Interval in seconds for Octavia statistics reporting. "
"0 means no reporting")),
]
nsx_v3_and_p = [

16
vmware_nsx/db/db.py
View File

@ -559,6 +559,10 @@ def get_nsx_lbaas_loadbalancer_binding(session, loadbalancer_id):
return
def get_nsx_lbaas_loadbalancer_bindings(session):
return session.query(nsx_models.NsxLbaasLoadbalancer).all()
def get_nsx_lbaas_loadbalancer_binding_by_service(session, lb_service_id):
return session.query(
nsx_models.NsxLbaasLoadbalancer).filter_by(
@ -591,7 +595,8 @@ def get_nsx_lbaas_listener_binding(session, loadbalancer_id, listener_id):
return
def get_nsx_lbaas_listener_binding_by_vs(session, loadbalancer_id, lb_vs_id):
def get_nsx_lbaas_listener_binding_by_lb_and_vs(session, loadbalancer_id,
lb_vs_id):
try:
return session.query(
nsx_models.NsxLbaasListener).filter_by(
@ -601,6 +606,15 @@ def get_nsx_lbaas_listener_binding_by_vs(session, loadbalancer_id, lb_vs_id):
return
def get_nsx_lbaas_listener_binding_by_vs_id(session, lb_vs_id):
try:
return session.query(
nsx_models.NsxLbaasListener).filter_by(
lb_vs_id=lb_vs_id).one()
except exc.NoResultFound:
return
def delete_nsx_lbaas_listener_binding(session, loadbalancer_id, listener_id):
return (session.query(nsx_models.NsxLbaasListener).
filter_by(loadbalancer_id=loadbalancer_id,

2
vmware_nsx/db/migration/alembic_migrations/versions/EXPAND_HEAD
View File

@ -1 +1 @@
0dbeda408e41
fc6308289aca

51
vmware_nsx/db/migration/alembic_migrations/versions/stein/expand/fc6308289aca_lbaas_no_foreign_key.py Normal file
View File

@ -0,0 +1,51 @@
# Copyright 2018 VMware, Inc.
#
# 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.
"""lbaas_no_foreign_key
Revision ID: fc6308289aca
Revises: 0dbeda408e41
Create Date: 2018-06-04 13:47:09.450116
"""
from alembic import op
from sqlalchemy.engine import reflection
from neutron.db import migration
# revision identifiers, used by Alembic.
revision = 'fc6308289aca'
down_revision = '0dbeda408e41'
depends_on = ('717f7f63a219')
def upgrade():
for table_name in ['nsxv3_lbaas_loadbalancers',
'nsxv3_lbaas_listeners',
'nsxv3_lbaas_pools',
'nsxv3_lbaas_monitors',
'nsxv3_lbaas_l7rules',
'nsxv3_lbaas_l7policies',
'nsxv_lbaas_loadbalancer_bindings',
'nsxv_lbaas_listener_bindings',
'nsxv_lbaas_pool_bindings',
'nsxv_lbaas_monitor_bindings',
'nsxv_lbaas_l7policy_bindings']:
if migration.schema_has_table(table_name):
inspector = reflection.Inspector.from_engine(op.get_bind())
fk_constraint = inspector.get_foreign_keys(table_name)[0]
op.drop_constraint(fk_constraint.get('name'), table_name,
type_='foreignkey')

37
vmware_nsx/db/nsx_models.py
View File

@ -399,12 +399,7 @@ class NsxLbaasLoadbalancer(model_base.BASEV2, models.TimestampMixin):
and NSX logical router id.
"""
__tablename__ = 'nsxv3_lbaas_loadbalancers'
fk_name = 'fk_nsxv3_lbaas_loadbalancers_id'
loadbalancer_id = sa.Column(sa.String(36),
sa.ForeignKey('lbaas_loadbalancers.id',
name=fk_name,
ondelete="CASCADE"),
primary_key=True)
loadbalancer_id = sa.Column(sa.String(36), primary_key=True)
lb_router_id = sa.Column(sa.String(36), nullable=False)
lb_service_id = sa.Column(sa.String(36), nullable=False)
vip_address = sa.Column(sa.String(36), nullable=False)
@ -414,11 +409,7 @@ class NsxLbaasListener(model_base.BASEV2, models.TimestampMixin):
"""Stores the mapping between LBaaS listener and NSX LB virtual server"""
__tablename__ = 'nsxv3_lbaas_listeners'
loadbalancer_id = sa.Column(sa.String(36), primary_key=True)
listener_id = sa.Column(sa.String(36),
sa.ForeignKey('lbaas_listeners.id',
name='fk_nsxv3_lbaas_listeners_id',
ondelete="CASCADE"),
primary_key=True)
listener_id = sa.Column(sa.String(36), primary_key=True)
app_profile_id = sa.Column(sa.String(36), nullable=False)
lb_vs_id = sa.Column(sa.String(36), nullable=False)
@ -427,11 +418,7 @@ class NsxLbaasPool(model_base.BASEV2, models.TimestampMixin):
"""Stores the mapping between LBaaS pool and NSX LB Pool"""
__tablename__ = 'nsxv3_lbaas_pools'
loadbalancer_id = sa.Column(sa.String(36), primary_key=True)
pool_id = sa.Column(sa.String(36),
sa.ForeignKey('lbaas_pools.id',
name='fk_nsxv3_lbaas_pools_id',
ondelete="CASCADE"),
primary_key=True)
pool_id = sa.Column(sa.String(36), primary_key=True)
lb_pool_id = sa.Column(sa.String(36), nullable=False)
lb_vs_id = sa.Column(sa.String(36))
@ -441,11 +428,7 @@ class NsxLbaasMonitor(model_base.BASEV2, models.TimestampMixin):
__tablename__ = 'nsxv3_lbaas_monitors'
loadbalancer_id = sa.Column(sa.String(36), primary_key=True)
pool_id = sa.Column(sa.String(36), primary_key=True)
hm_id = sa.Column(sa.String(36),
sa.ForeignKey('lbaas_healthmonitors.id',
name='fk_nsxv3_lbaas_healthmonitors_id',
ondelete="CASCADE"),
primary_key=True)
hm_id = sa.Column(sa.String(36), primary_key=True)
lb_monitor_id = sa.Column(sa.String(36), nullable=False)
lb_pool_id = sa.Column(sa.String(36), nullable=False)
@ -462,11 +445,7 @@ class NsxLbaasL7Rule(model_base.BASEV2, models.TimestampMixin):
__tablename__ = 'nsxv3_lbaas_l7rules'
loadbalancer_id = sa.Column(sa.String(36), primary_key=True)
l7policy_id = sa.Column(sa.String(36), primary_key=True)
l7rule_id = sa.Column(sa.String(36),
sa.ForeignKey('lbaas_l7rules.id',
name='fk_nsxv3_lbaas_l7rules_id',
ondelete="CASCADE"),
primary_key=True)
l7rule_id = sa.Column(sa.String(36), primary_key=True)
lb_rule_id = sa.Column(sa.String(36), nullable=False)
lb_vs_id = sa.Column(sa.String(36), nullable=False)
@ -474,11 +453,7 @@ class NsxLbaasL7Rule(model_base.BASEV2, models.TimestampMixin):
class NsxLbaasL7Policy(model_base.BASEV2, models.TimestampMixin):
"""Stores the mapping between LBaaS l7policy and NSX LB rule"""
__tablename__ = 'nsxv3_lbaas_l7policies'
l7policy_id = sa.Column(sa.String(36),
sa.ForeignKey('lbaas_l7policies.id',
name='fk_nsxv3_lbaas_l7policies_id',
ondelete="CASCADE"),
primary_key=True)
l7policy_id = sa.Column(sa.String(36), primary_key=True)
lb_rule_id = sa.Column(sa.String(36), nullable=False)
lb_vs_id = sa.Column(sa.String(36), nullable=False)

18
vmware_nsx/db/nsxv_db.py
View File

@ -684,6 +684,15 @@ def add_nsxv_lbaas_loadbalancer_binding(
return binding
def get_nsxv_lbaas_loadbalancer_bindings(session, filters=None,
like_filters=None):
session = db_api.get_reader_session()
query = session.query(nsxv_models.NsxvLbaasLoadbalancerBinding)
return nsx_db._apply_filters_to_query(
query, nsxv_models.NsxvLbaasLoadbalancerBinding, filters,
like_filters).all()
def get_nsxv_lbaas_loadbalancer_binding(session, loadbalancer_id):
try:
return session.query(
@ -731,6 +740,15 @@ def del_nsxv_lbaas_listener_binding(session, loadbalancer_id, listener_id):
listener_id=listener_id).delete())
def get_nsxv_lbaas_listener_binding_by_vse(session, loadbalancer_id, vse_id):
try:
return session.query(
nsxv_models.NsxvLbaasListenerBinding).filter_by(
loadbalancer_id=loadbalancer_id, vse_id=vse_id).one()
except exc.NoResultFound:
return
def add_nsxv_lbaas_pool_binding(session, loadbalancer_id, pool_id,
edge_pool_id):
with session.begin(subtransactions=True):

30
vmware_nsx/db/nsxv_models.py
View File

@ -252,11 +252,7 @@ class NsxvLbaasLoadbalancerBinding(model_base.BASEV2, models.TimestampMixin):
__tablename__ = 'nsxv_lbaas_loadbalancer_bindings'
loadbalancer_id = sa.Column(sa.String(36),
sa.ForeignKey('lbaas_loadbalancers.id',
name='fk_lbaas_loadbalancers_id',
ondelete="CASCADE"),
primary_key=True)
loadbalancer_id = sa.Column(sa.String(36), primary_key=True)
edge_id = sa.Column(sa.String(36), nullable=False)
edge_fw_rule_id = sa.Column(sa.String(36), nullable=False)
vip_address = sa.Column(sa.String(36), nullable=False)
@ -268,11 +264,7 @@ class NsxvLbaasListenerBinding(model_base.BASEV2, models.TimestampMixin):
__tablename__ = 'nsxv_lbaas_listener_bindings'
loadbalancer_id = sa.Column(sa.String(36), primary_key=True)
listener_id = sa.Column(sa.String(36),
sa.ForeignKey('lbaas_listeners.id',
name='fk_lbaas_listeners_id',
ondelete="CASCADE"),
primary_key=True)
listener_id = sa.Column(sa.String(36), primary_key=True)
app_profile_id = sa.Column(sa.String(36), nullable=False)
vse_id = sa.Column(sa.String(36), nullable=False)
@ -283,11 +275,7 @@ class NsxvLbaasPoolBinding(model_base.BASEV2, models.TimestampMixin):
__tablename__ = 'nsxv_lbaas_pool_bindings'
loadbalancer_id = sa.Column(sa.String(36), primary_key=True)
pool_id = sa.Column(sa.String(36),
sa.ForeignKey('lbaas_pools.id',
name='fk_lbaas_pools_id',
ondelete="CASCADE"),
primary_key=True)
pool_id = sa.Column(sa.String(36), primary_key=True)
edge_pool_id = sa.Column(sa.String(36), nullable=False)
@ -298,11 +286,7 @@ class NsxvLbaasMonitorBinding(model_base.BASEV2, models.TimestampMixin):
loadbalancer_id = sa.Column(sa.String(36), primary_key=True)
pool_id = sa.Column(sa.String(36), primary_key=True)
hm_id = sa.Column(sa.String(36),
sa.ForeignKey('lbaas_healthmonitors.id',
name='fk_lbaas_healthmonitors_id',
ondelete="CASCADE"),
primary_key=True)
hm_id = sa.Column(sa.String(36), primary_key=True)
edge_id = sa.Column(sa.String(36), primary_key=True)
edge_mon_id = sa.Column(sa.String(36), nullable=False)
@ -322,11 +306,7 @@ class NsxvLbaasL7PolicyBinding(model_base.BASEV2, models.TimestampMixin):
__tablename__ = 'nsxv_lbaas_l7policy_bindings'
policy_id = sa.Column(sa.String(36),
sa.ForeignKey('lbaas_l7policies.id',
name='fk_lbaas_l7policies_id',
ondelete="CASCADE"),
primary_key=True)
policy_id = sa.Column(sa.String(36), primary_key=True)
edge_id = sa.Column(sa.String(36), nullable=False)
edge_app_rule_id = sa.Column(sa.String(36), nullable=False)

9
vmware_nsx/plugins/nsx_v/drivers/exclusive_router_driver.py
View File

@ -16,7 +16,6 @@ from oslo_log import log as logging
from neutron_lib import constants as n_consts
from neutron_lib.db import api as db_api
from neutron_lib.plugins import constants as plugin_const
from vmware_nsx._i18n import _
from vmware_nsx.common import exceptions as nsxv_exc
@ -26,6 +25,7 @@ from vmware_nsx.plugins.nsx_v.drivers import (
abstract_router_driver as router_driver)
from vmware_nsx.plugins.nsx_v import plugin as nsx_v
from vmware_nsx.plugins.nsx_v.vshield import edge_utils
from vmware_nsx.services.lbaas.octavia import constants as oct_const
LOG = logging.getLogger(__name__)
@ -279,9 +279,10 @@ class RouterExclusiveDriver(router_driver.RouterBaseDriver):
def _check_lb_on_subnet(self, context, subnet_id, router_id):
# Check lbaas
dev_owner_v1 = 'neutron:' + plugin_const.LOADBALANCER
dev_owner_v2 = 'neutron:' + plugin_const.LOADBALANCERV2
filters = {'device_owner': [dev_owner_v1, dev_owner_v2],
dev_owner_v1 = n_consts.DEVICE_OWNER_LOADBALANCER
dev_owner_v2 = n_consts.DEVICE_OWNER_LOADBALANCERV2
dev_owner_oct = oct_const.DEVICE_OWNER_OCTAVIA
filters = {'device_owner': [dev_owner_v1, dev_owner_v2, dev_owner_oct],
'fixed_ips': {'subnet_id': [subnet_id]}}
ports = super(nsx_v.NsxVPluginV2, self.plugin).get_ports(
context, filters=filters)

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

@ -143,6 +143,15 @@ from vmware_nsx.plugins.nsx_v.vshield import securitygroup_utils
from vmware_nsx.plugins.nsx_v.vshield import vcns_driver
from vmware_nsx.services.flowclassifier.nsx_v import utils as fc_utils
from vmware_nsx.services.fwaas.nsx_v import fwaas_callbacks
from vmware_nsx.services.lbaas.nsx_v.implementation import healthmon_mgr
from vmware_nsx.services.lbaas.nsx_v.implementation import l7policy_mgr
from vmware_nsx.services.lbaas.nsx_v.implementation import l7rule_mgr
from vmware_nsx.services.lbaas.nsx_v.implementation import listener_mgr
from vmware_nsx.services.lbaas.nsx_v.implementation import loadbalancer_mgr
from vmware_nsx.services.lbaas.nsx_v.implementation import member_mgr
from vmware_nsx.services.lbaas.nsx_v.implementation import pool_mgr
from vmware_nsx.services.lbaas.octavia import constants as oct_const
from vmware_nsx.services.lbaas.octavia import octavia_listener
LOG = logging.getLogger(__name__)
PORTGROUP_PREFIX = 'dvportgroup'
@ -226,6 +235,8 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
def __init__(self):
self._is_sub_plugin = tvd_utils.is_tvd_core_plugin()
self.init_is_complete = False
self.octavia_listener = None
self.octavia_stats_collector = None
self.housekeeper = None
super(NsxVPluginV2, self).__init__()
if self._is_sub_plugin:
@ -321,6 +332,10 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
# Bind QoS notifications
qos_driver.register(self)
registry.subscribe(self.spawn_complete,
resources.PROCESS,
events.AFTER_SPAWN)
# subscribe the init complete method last, so it will be called only
# if init was successful
registry.subscribe(self.init_complete,
@ -335,6 +350,16 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
def is_tvd_plugin():
return False
def spawn_complete(self, resource, event, trigger, payload=None):
# This method should run only once, but after init_complete
if not self.init_is_complete:
self.init_complete(None, None, None)
self.octavia_stats_collector = (
octavia_listener.NSXOctaviaStatisticsCollector(
self,
listener_mgr.stats_getter))
def init_complete(self, resource, event, trigger, payload=None):
with locking.LockManager.get_lock('plugin-init-complete'):
if self.init_is_complete:
@ -362,6 +387,18 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
hk_readonly=cfg.CONF.nsxv.housekeeping_readonly,
hk_readonly_jobs=cfg.CONF.nsxv.housekeeping_readonly_jobs)
# Init octavia listener and endpoints
self.octavia_listener = octavia_listener.NSXOctaviaListener(
loadbalancer=loadbalancer_mgr.EdgeLoadBalancerManagerFromDict(
self.nsx_v),
listener=listener_mgr.EdgeListenerManagerFromDict(self.nsx_v),
pool=pool_mgr.EdgePoolManagerFromDict(self.nsx_v),
member=member_mgr.EdgeMemberManagerFromDict(self.nsx_v),
healthmonitor=healthmon_mgr.EdgeHealthMonitorManagerFromDict(
self.nsx_v),
l7policy=l7policy_mgr.EdgeL7PolicyManagerFromDict(self.nsx_v),
l7rule=l7rule_mgr.EdgeL7RuleManagerFromDict(self.nsx_v))
self.init_is_complete = True
def _validate_nsx_version(self):
@ -1851,7 +1888,8 @@ class NsxVPluginV2(addr_pair_db.AllowedAddressPairsMixin,
def _assert_on_lb_port_admin_state(self, port_data, original_port,
device_owner):
if device_owner == constants.DEVICE_OWNER_LOADBALANCERV2:
if device_owner in [constants.DEVICE_OWNER_LOADBALANCERV2,
oct_const.DEVICE_OWNER_OCTAVIA]:
orig_state = original_port.get("admin_state_up")
new_state = port_data.get("admin_state_up")
if new_state is not None and (orig_state != new_state) and (

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

@ -116,7 +116,16 @@ from vmware_nsx.plugins.nsx_v3 import utils as v3_utils
from vmware_nsx.services.fwaas.common import utils as fwaas_utils
from vmware_nsx.services.fwaas.nsx_v3 import fwaas_callbacks_v1
from vmware_nsx.services.fwaas.nsx_v3 import fwaas_callbacks_v2
from vmware_nsx.services.lbaas.nsx_v3.implementation import healthmonitor_mgr
from vmware_nsx.services.lbaas.nsx_v3.implementation import l7policy_mgr
from vmware_nsx.services.lbaas.nsx_v3.implementation import l7rule_mgr
from vmware_nsx.services.lbaas.nsx_v3.implementation import listener_mgr
from vmware_nsx.services.lbaas.nsx_v3.implementation import loadbalancer_mgr
from vmware_nsx.services.lbaas.nsx_v3.implementation import member_mgr
from vmware_nsx.services.lbaas.nsx_v3.implementation import pool_mgr
from vmware_nsx.services.lbaas.nsx_v3.v2 import lb_driver_v2
from vmware_nsx.services.lbaas.octavia import constants as oct_const
from vmware_nsx.services.lbaas.octavia import octavia_listener
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.trunk.nsx_v3 import driver as trunk_driver
@ -211,6 +220,8 @@ class NsxV3Plugin(agentschedulers_db.AZDhcpAgentSchedulerDbMixin,
self.fwaas_callbacks = None
self._is_sub_plugin = tvd_utils.is_tvd_core_plugin()
self.init_is_complete = False
self.octavia_listener = None
self.octavia_stats_collector = None
nsxlib_utils.set_is_attr_callback(validators.is_attr_set)
self._extend_fault_map()
if self._is_sub_plugin:
@ -293,6 +304,10 @@ class NsxV3Plugin(agentschedulers_db.AZDhcpAgentSchedulerDbMixin,
# Register NSXv3 trunk driver to support trunk extensions
self.trunk_driver = trunk_driver.NsxV3TrunkDriver.create(self)
registry.subscribe(self.spawn_complete,
resources.PROCESS,
events.AFTER_SPAWN)
# subscribe the init complete method last, so it will be called only
# if init was successful
registry.subscribe(self.init_complete,
@ -430,6 +445,16 @@ class NsxV3Plugin(agentschedulers_db.AZDhcpAgentSchedulerDbMixin,
def is_tvd_plugin():
return False
def spawn_complete(self, resource, event, trigger, payload=None):
# This method should run only once, but after init_complete
if not self.init_is_complete:
self.init_complete(None, None, None)
self.octavia_stats_collector = (
octavia_listener.NSXOctaviaStatisticsCollector(
self,
listener_mgr.stats_getter))
def init_complete(self, resource, event, trigger, payload=None):
with locking.LockManager.get_lock('plugin-init-complete'):
if self.init_is_complete:
@ -451,8 +476,25 @@ class NsxV3Plugin(agentschedulers_db.AZDhcpAgentSchedulerDbMixin,
hk_readonly=cfg.CONF.nsx_v3.housekeeping_readonly,
hk_readonly_jobs=cfg.CONF.nsx_v3.housekeeping_readonly_jobs)
# Init octavia listener and endpoints
self._init_octavia()
self.init_is_complete = True
def _init_octavia(self):
if not self.nsxlib.feature_supported(
nsxlib_consts.FEATURE_LOAD_BALANCER):
return
self.octavia_listener = octavia_listener.NSXOctaviaListener(
loadbalancer=loadbalancer_mgr.EdgeLoadBalancerManagerFromDict(),
listener=listener_mgr.EdgeListenerManagerFromDict(),
pool=pool_mgr.EdgePoolManagerFromDict(),
member=member_mgr.EdgeMemberManagerFromDict(),
healthmonitor=healthmonitor_mgr.EdgeHealthMonitorManagerFromDict(),
l7policy=l7policy_mgr.EdgeL7PolicyManagerFromDict(),
l7rule=l7rule_mgr.EdgeL7RuleManagerFromDict())
def _extend_fault_map(self):
"""Extends the Neutron Fault Map.
@ -4479,7 +4521,8 @@ class NsxV3Plugin(agentschedulers_db.AZDhcpAgentSchedulerDbMixin,
port_data = self.get_port(context, port_id)
device_owner = port_data.get('device_owner')
fip_address = new_fip['floating_ip_address']
if device_owner == const.DEVICE_OWNER_LOADBALANCERV2:
if (device_owner == const.DEVICE_OWNER_LOADBALANCERV2 or
device_owner == oct_const.DEVICE_OWNER_OCTAVIA):
try:
self._update_lb_vip(port_data, fip_address)
except nsx_lib_exc.ManagerError:
@ -4508,7 +4551,8 @@ class NsxV3Plugin(agentschedulers_db.AZDhcpAgentSchedulerDbMixin,
port_data = self.get_port(context, port_id)
device_owner = port_data.get('device_owner')
fixed_ip_address = fip['fixed_ip_address']
if device_owner == const.DEVICE_OWNER_LOADBALANCERV2:
if (device_owner == const.DEVICE_OWNER_LOADBALANCERV2 or
device_owner == oct_const.DEVICE_OWNER_OCTAVIA):
# If the port is LB VIP port, after deleting the FIP,
# update the virtual server VIP back to fixed IP.
is_lb_port = True
@ -4551,7 +4595,8 @@ class NsxV3Plugin(agentschedulers_db.AZDhcpAgentSchedulerDbMixin,
old_port_data = self.get_port(context, old_port_id)
old_device_owner = old_port_data['device_owner']
old_fixed_ip = old_fip['fixed_ip_address']
if old_device_owner == const.DEVICE_OWNER_LOADBALANCERV2:
if (old_device_owner == const.DEVICE_OWNER_LOADBALANCERV2 or
old_device_owner == oct_const.DEVICE_OWNER_OCTAVIA):
is_lb_port = True
self._update_lb_vip(old_port_data, old_fixed_ip)
@ -4578,7 +4623,8 @@ class NsxV3Plugin(agentschedulers_db.AZDhcpAgentSchedulerDbMixin,
new_port_data = self.get_port(context, new_port_id)
new_dev_own = new_port_data['device_owner']
new_fip_address = new_fip['floating_ip_address']
if new_dev_own == const.DEVICE_OWNER_LOADBALANCERV2:
if (new_dev_own == const.DEVICE_OWNER_LOADBALANCERV2 or
new_dev_own == oct_const.DEVICE_OWNER_OCTAVIA):
is_lb_port = True
self._update_lb_vip(new_port_data, new_fip_address)

4
vmware_nsx/services/lbaas/lb_const.py
View File

@ -96,6 +96,10 @@ LB_STATS_MAP = {'active_connections': 'current_sessions',
'bytes_in': 'bytes_in',
'bytes_out': 'bytes_out',
'total_connections': 'total_sessions'}
LB_EMPTY_STATS = {'active_connections': 0,
'bytes_in': 0,
'bytes_out': 0,
'total_connections': 0}
LR_ROUTER_TYPE = 'os-neutron-router-id'
LR_PORT_TYPE = 'os-neutron-rport-id'
LB_CERT_RESOURCE_TYPE = ['certificate_signed', 'certificate_self_signed']

2
vmware_nsx/services/lbaas/lb_translators.py
View File

@ -32,12 +32,14 @@ def lb_listener_obj_to_dict(listener):
# Translate the LBaaS listener to a dictionary skipping the some objects
# to avoid recursions
listener_dict = listener.to_dict(loadbalancer=False, default_pool=False)
# Translate the default pool separately without it's internal objects
if listener.default_pool:
listener_dict['default_pool'] = lb_pool_obj_to_dict(
listener.default_pool, with_listeners=False)
else:
listener_dict['default_pool'] = None
if listener.loadbalancer:
listener_dict['loadbalancer'] = lb_loadbalancer_obj_to_dict(
listener.loadbalancer)

44
vmware_nsx/services/lbaas/nsx_v/implementation/listener_mgr.py
View File

@ -13,6 +13,8 @@
# License for the specific language governing permissions and limitations
# under the License.
import copy
from oslo_log import helpers as log_helpers
from oslo_log import log as logging
from oslo_utils import excutils
@ -297,3 +299,45 @@ class EdgeListenerManagerFromDict(base_mgr.EdgeLoadbalancerBaseManager):
listener['id'])
completor(success=True)
def stats_getter(context, core_plugin, ignore_list=None):
"""Update Octavia statistics for each listener (virtual server)"""
stat_list = []
vcns = core_plugin.nsx_v.vcns
# go over all LB edges
bindings = nsxv_db.get_nsxv_lbaas_loadbalancer_bindings(context.session)
for binding in bindings:
lb_id = binding['loadbalancer_id']
if ignore_list and lb_id in ignore_list:
continue
edge_id = binding['edge_id']
try:
lb_stats = vcns.get_loadbalancer_statistics(edge_id)
virtual_servers_stats = lb_stats[1].get('virtualServer', [])
for vs_stats in virtual_servers_stats:
# Get the stats of the virtual server
stats = copy.copy(lb_const.LB_EMPTY_STATS)
stats['bytes_in'] += vs_stats.get('bytesIn', 0)
stats['bytes_out'] += vs_stats.get('bytesOut', 0)
stats['active_connections'] += vs_stats.get('curSessions', 0)
stats['total_connections'] += vs_stats.get('totalSessions', 0)
stats['request_errors'] = 0 # currently unsupported
# Find the listener Id
vs_id = vs_stats.get('virtualServerId')
list_bind = nsxv_db.get_nsxv_lbaas_listener_binding_by_vse(
context.session, lb_id, vs_id)
if not list_bind:
continue
stats['id'] = list_bind['listener_id']
stat_list.append(stats)
except vcns_exc.VcnsApiException as e:
LOG.warning('Failed to read load balancer statistics for %s: %s',
edge_id, e)
return stat_list

54
vmware_nsx/services/lbaas/nsx_v/implementation/loadbalancer_mgr.py
View File

@ -31,6 +31,7 @@ from vmware_nsx.plugins.nsx_v.vshield.common import (
from vmware_nsx.plugins.nsx_v.vshield.common import exceptions as nsxv_exc
from vmware_nsx.services.lbaas import base_mgr
from vmware_nsx.services.lbaas.nsx_v import lbaas_common as lb_common
from vmware_nsx.services.lbaas.octavia import constants as oct_const
LOG = logging.getLogger(__name__)
@ -159,33 +160,15 @@ class EdgeLoadBalancerManagerFromDict(base_mgr.EdgeLoadbalancerBaseManager):
completor(success=True)
def refresh(self, context, lb):
# TODO(kobis): implememnt
# TODO(kobis): implement
pass
def stats(self, context, lb):
stats = {'bytes_in': 0,
'bytes_out': 0,
'active_connections': 0,
'total_connections': 0}
binding = nsxv_db.get_nsxv_lbaas_loadbalancer_binding(context.session,
lb['id'])
try:
lb_stats = self.vcns.get_loadbalancer_statistics(
binding['edge_id'])
except nsxv_exc.VcnsApiException:
msg = (_('Failed to read load balancer statistics, edge: %s') %
binding['edge_id'])
raise n_exc.BadRequest(resource='edge-lbaas', msg=msg)
pools_stats = lb_stats[1].get('pool', [])
for pool_stats in pools_stats:
stats['bytes_in'] += pool_stats.get('bytesIn', 0)
stats['bytes_out'] += pool_stats.get('bytesOut', 0)
stats['active_connections'] += pool_stats.get('curSessions', 0)
stats['total_connections'] += pool_stats.get('totalSessions', 0)
stats = _get_edge_loadbalancer_statistics(self.vcns,
binding['edge_id'])
return stats
@ -208,12 +191,15 @@ class EdgeLoadBalancerManagerFromDict(base_mgr.EdgeLoadbalancerBaseManager):
subnet = self.core_plugin.get_subnet(context.elevated(), subnet_id)
filters = {'fixed_ips': {'subnet_id': [subnet_id]},
'device_owner': [constants.DEVICE_OWNER_LOADBALANCERV2]}
'device_owner': [constants.DEVICE_OWNER_LOADBALANCERV2,
oct_const.DEVICE_OWNER_OCTAVIA]}
lb_ports = self.core_plugin.get_ports(context.elevated(),
filters=filters)
if lb_ports:
for lb_port in lb_ports:
# TODO(asarfaty): for Octavia this code might need to change
# as the device_id is different
if lb_port['device_id']:
edge_bind = nsxv_db.get_nsxv_lbaas_loadbalancer_binding(
context.session, lb_port['device_id'])
@ -238,3 +224,27 @@ class EdgeLoadBalancerManagerFromDict(base_mgr.EdgeLoadbalancerBaseManager):
if not found:
return False
return True
def _get_edge_loadbalancer_statistics(vcns, edge_id):
stats = {'bytes_in': 0,
'bytes_out': 0,
'active_connections': 0,
'total_connections': 0}
try:
lb_stats = vcns.get_loadbalancer_statistics(edge_id)
except nsxv_exc.VcnsApiException:
msg = (_('Failed to read load balancer statistics, edge: %s') %
edge_id)
raise n_exc.BadRequest(resource='edge-lbaas', msg=msg)
pools_stats = lb_stats[1].get('pool', [])
for pool_stats in pools_stats:
stats['bytes_in'] += pool_stats.get('bytesIn', 0)
stats['bytes_out'] += pool_stats.get('bytesOut', 0)
stats['active_connections'] += pool_stats.get('curSessions', 0)
stats['total_connections'] += pool_stats.get('totalSessions', 0)
return stats

2
vmware_nsx/services/lbaas/nsx_v3/implementation/l7rule_mgr.py
View File

@ -46,6 +46,8 @@ class EdgeL7RuleManagerFromDict(base_mgr.Nsxv3LoadbalancerBaseManager):
lb_rule_id = binding['lb_rule_id']
if delete:
lb_utils.remove_rule_from_policy(rule)
else:
lb_utils.update_rule_in_policy(rule)
rule_body = lb_utils.convert_l7policy_to_lb_rule(
context, rule['policy'])
try:

5
vmware_nsx/services/lbaas/nsx_v3/implementation/lb_utils.py
View File

@ -203,3 +203,8 @@ def convert_l7policy_to_lb_rule(context, policy):
def remove_rule_from_policy(rule):
l7rules = rule['policy']['rules']
rule['policy']['rules'] = [r for r in l7rules if r['id'] != rule['id']]
def update_rule_in_policy(rule):
remove_rule_from_policy(rule)
rule['policy']['rules'].append(rule)

41
vmware_nsx/services/lbaas/nsx_v3/implementation/listener_mgr.py
View File

@ -13,6 +13,8 @@
# License for the specific language governing permissions and limitations
# under the License.
import copy
from neutron_lib import exceptions as n_exc
from oslo_log import helpers as log_helpers
from oslo_log import log as logging
@ -281,3 +283,42 @@ class EdgeListenerManagerFromDict(base_mgr.Nsxv3LoadbalancerBaseManager):
context.session, lb_id, listener['id'])
completor(success=True)
def stats_getter(context, core_plugin, ignore_list=None):
"""Update Octavia statistics for each listener (virtual server)"""
stat_list = []
lb_service_client = core_plugin.nsxlib.load_balancer.service
# Go over all the loadbalancers & services
lb_bindings = nsx_db.get_nsx_lbaas_loadbalancer_bindings(
context.session)
for lb_binding in lb_bindings:
if ignore_list and lb_binding['loadbalancer_id'] in ignore_list:
continue
lb_service_id = lb_binding.get('lb_service_id')
LOG.debug("Getting listeners statistics for NSX lb service %s",
lb_service_id)
try:
# get the NSX statistics for this LB service
rsp = lb_service_client.get_stats(lb_service_id)
if rsp and 'virtual_servers' in rsp:
# Go over each virtual server in the response
for vs in rsp['virtual_servers']:
# look up the virtual server in the DB
vs_bind = nsx_db.get_nsx_lbaas_listener_binding_by_vs_id(
context.session, vs['virtual_server_id'])
if vs_bind:
vs_stats = vs['statistics']
stats = copy.copy(lb_const.LB_EMPTY_STATS)
stats['id'] = vs_bind.listener_id
stats['request_errors'] = 0 # currently unsupported
for stat in lb_const.LB_STATS_MAP:
lb_stat = lb_const.LB_STATS_MAP[stat]
stats[stat] += vs_stats[lb_stat]
stat_list.append(stats)
except nsxlib_exc.ManagerError:
pass
return stat_list

6
vmware_nsx/services/lbaas/nsx_v3/implementation/loadbalancer_mgr.py
View File

@ -192,10 +192,10 @@ class EdgeLoadBalancerManagerFromDict(base_mgr.Nsxv3LoadbalancerBaseManager):
for vs in vs_statuses.get('results', []):
vs_status = self._nsx_status_to_lb_status(vs.get('status'))
vs_id = vs.get('virtual_server_id')
listener_binding = nsx_db.get_nsx_lbaas_listener_binding_by_vs(
list_binding = nsx_db.get_nsx_lbaas_listener_binding_by_lb_and_vs(
context.session, id, vs_id)
if listener_binding:
listener_id = listener_binding['listener_id']
if list_binding:
listener_id = list_binding['listener_id']
statuses[lb_const.LISTENERS].append(
{'id': listener_id, 'status': vs_status})

13
vmware_nsx/services/lbaas/nsx_v3/implementation/member_mgr.py
View File

@ -65,10 +65,15 @@ class EdgeMemberManagerFromDict(base_mgr.Nsxv3LoadbalancerBaseManager):
tenant_id, context.project_name)
attachment = {'target_id': nsx_router_id,
'target_type': 'LogicalRouter'}
lb_service = service_client.create(display_name=lb_name,
tags=tags,
attachment=attachment,
size=lb_size)
try:
lb_service = service_client.create(display_name=lb_name,
tags=tags,
attachment=attachment,
size=lb_size)
except nsxlib_exc.ManagerError as e:
LOG.error("Failed to create LB service: %s", e)
return
# Update router to enable advertise_lb_vip flag
self.core_plugin.nsxlib.logical_router.update_advertisement(
nsx_router_id, advertise_lb_vip=True)

11
vmware_nsx/services/lbaas/nsx_v3/v2/lb_driver_v2.py
View File

@ -16,8 +16,8 @@
from neutron_lib.callbacks import events
from neutron_lib.callbacks import registry
from neutron_lib.callbacks import resources
from neutron_lib import constants as n_consts
from neutron_lib import exceptions as n_exc
from neutron_lib.plugins import constants as plugin_const
from oslo_log import helpers as log_helpers
from oslo_log import log as logging
@ -33,6 +33,7 @@ from vmware_nsx.services.lbaas.nsx_v3.implementation import listener_mgr
from vmware_nsx.services.lbaas.nsx_v3.implementation import loadbalancer_mgr
from vmware_nsx.services.lbaas.nsx_v3.implementation import member_mgr
from vmware_nsx.services.lbaas.nsx_v3.implementation import pool_mgr
from vmware_nsx.services.lbaas.octavia import constants as oct_const
LOG = logging.getLogger(__name__)
@ -108,6 +109,9 @@ class EdgeLoadbalancerDriverV2(base_mgr.LoadbalancerBaseManager):
# Check if there is any LB attachment for the NSX router.
# This callback is subscribed here to prevent router/GW/interface
# deletion if it still has LB service attached to it.
#Note(asarfaty): Those callbacks are used by Octavia as well even
# though they are bound only here
registry.subscribe(self._check_lb_service_on_router,
resources.ROUTER, events.BEFORE_DELETE)
registry.subscribe(self._check_lb_service_on_router,
@ -124,8 +128,9 @@ class EdgeLoadbalancerDriverV2(base_mgr.LoadbalancerBaseManager):
resources.ROUTER_INTERFACE, events.BEFORE_DELETE)
def _get_lb_ports(self, context, subnet_ids):
dev_owner = 'neutron:' + plugin_const.LOADBALANCERV2
filters = {'device_owner': [dev_owner],
dev_owner_v2 = n_consts.DEVICE_OWNER_LOADBALANCERV2
dev_owner_oct = oct_const.DEVICE_OWNER_OCTAVIA
filters = {'device_owner': [dev_owner_v2, dev_owner_oct],
'fixed_ips': {'subnet_id': subnet_ids}}
return self.loadbalancer.core_plugin.get_ports(
context, filters=filters)

0
vmware_nsx/services/lbaas/octavia/__init__.py Normal file
View File

45
vmware_nsx/services/lbaas/octavia/constants.py Normal file
View File

@ -0,0 +1,45 @@
# Copyright 2018 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.
OCTAVIA_TO_DRIVER_TOPIC = 'vmware_nsx__lb_listener'
DRIVER_TO_OCTAVIA_TOPIC = 'vmware_nsx__driver_listener'
LOADBALANCER = 'loadbalancer'
LISTENER = 'listener'
POOL = 'pool'
HEALTHMONITOR = 'healthmonitor'
MEMBER = 'member'
L7POLICY = 'l7policy'
L7RULE = 'l7rule'
LOADBALANCERS = 'loadbalancers'
LISTENERS = 'listeners'
POOLS = 'pools'
HEALTHMONITORS = 'healthmonitors'
MEMBERS = 'members'
L7POLICIES = 'l7policies'
L7RULES = 'l7rules'
ONLINE = 'ONLINE'
OFFLINE = 'OFFLINE'
ERROR = 'ERROR'
ACTIVE = 'ACTIVE'
DELETED = 'DELETED'
ERROR = 'ERROR'
OPERATING_STATUS = 'operating_status'
PROVISIONING_STATUS = 'provisioning_status'
DEVICE_OWNER_OCTAVIA = 'Octavia'

507
vmware_nsx/services/lbaas/octavia/octavia_driver.py Normal file
View File

@ -0,0 +1,507 @@
# Copyright 2018 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 copy
import socket
from oslo_config import cfg
from oslo_log import helpers as log_helpers
from oslo_log import log as logging
import oslo_messaging as messaging
from oslo_messaging.rpc import dispatcher
import pecan
from stevedore import driver as stevedore_driver
from octavia.api.drivers import driver_lib
from octavia.api.drivers import exceptions
from octavia.api.drivers import provider_base as driver_base
from octavia.api.drivers import utils as oct_utils
from octavia.db import api as db_apis
from octavia.db import repositories
from vmware_nsx.services.lbaas.octavia import constants as d_const
LOG = logging.getLogger(__name__)
cfg.CONF.import_group('oslo_messaging', 'octavia.common.config')
# List of keys per object type that will not be sent to the listener
unsupported_keys = {'Loadbalancer': ['vip_qos_policy_id'],
'Listener': ['sni_container_refs',
'insert_headers',
'timeout_client_data',
'timeout_member_connect',
'timeout_member_data',
'timeout_tcp_inspect'],
'HealthMonitor': ['expected_codes', 'max_retries_down'],
'Member': ['monitor_address', 'monitor_port', 'backup']}
class NSXOctaviaDriver(driver_base.ProviderDriver):
@log_helpers.log_method_call
def __init__(self):
super(NSXOctaviaDriver, self).__init__()
self._init_rpc_messaging()
self._init_rpc_listener()
self._init_cert_manager()
self.repositories = repositories.Repositories()
@log_helpers.log_method_call
def _init_rpc_messaging(self):
topic = d_const.OCTAVIA_TO_DRIVER_TOPIC
transport = messaging.get_rpc_transport(cfg.CONF)
target = messaging.Target(topic=topic, exchange="common",
namespace='control', fanout=False,
version='1.0')
self.client = messaging.RPCClient(transport, target)
@log_helpers.log_method_call
def _init_rpc_listener(self):
# Initialize RPC listener
topic = d_const.DRIVER_TO_OCTAVIA_TOPIC
server = socket.gethostname()
transport = messaging.get_rpc_transport(cfg.CONF)
target = messaging.Target(topic=topic, server=server,
exchange="common", fanout=False)
endpoints = [NSXOctaviaDriverEndpoint()]
access_policy = dispatcher.DefaultRPCAccessPolicy
self.octavia_server = messaging.get_rpc_server(
transport, target, endpoints, executor='threading',
access_policy=access_policy)
self.octavia_server.start()
@log_helpers.log_method_call
def _init_cert_manager(self):
self.cert_manager = stevedore_driver.DriverManager(
namespace='octavia.cert_manager',
name=cfg.CONF.certificates.cert_manager,
invoke_on_load=True).driver
def get_obj_project_id(self, obj_type, obj_dict):
if obj_dict.get('project_id'):
return obj_dict['project_id']
if obj_dict.get('tenant_id'):
return obj_dict['tenant_id']
# look for the project id of the attached objects
project_id = None
if obj_dict.get('loadbalancer_id'):
db_lb = self.repositories.load_balancer.get(
db_apis.get_session(), id=obj_dict['loadbalancer_id'])
if db_lb:
project_id = db_lb.project_id
if not project_id and obj_dict.get('pool_id'):
db_pool = self.repositories.pool.get(
db_apis.get_session(), id=obj_dict['pool_id'])
if db_pool:
project_id = db_pool.load_balancer.project_id
if not project_id and obj_dict.get('listener_id'):
db_list = self.repositories.listener.get(
db_apis.get_session(), id=obj_dict['listener_id'])
if db_list:
project_id = db_list.load_balancer.project_id
if not project_id and obj_dict.get('l7policy_id'):
db_policy = self.repositories.l7policy.get(
db_apis.get_session(), id=obj_dict['l7policy_id'])
if db_policy:
if db_policy.listener:
db_lb = db_policy.listener.load_balancer
elif db_policy.redirect_pool:
db_lb = db_policy.redirect_pool.load_balancer
if db_lb:
project_id = db_lb.project_id
if not project_id:
LOG.warning("Could bot find the tenant id for %(type)s "
"%(obj)s", {'type': obj_type, 'obj': obj_dict})
return project_id
def _get_load_balancer_dict(self, loadbalancer_id):
if not loadbalancer_id:
return
db_lb = self.repositories.load_balancer.get(
db_apis.get_session(), id=loadbalancer_id)
if not db_lb:
return
lb_dict = {'name': db_lb.name, 'id': loadbalancer_id}
if db_lb.vip:
lb_dict['vip_port_id'] = db_lb.vip.port_id
lb_dict['vip_address'] = db_lb.vip.ip_address
lb_dict['vip_port_id'] = db_lb.vip.port_id
lb_dict['vip_network_id'] = db_lb.vip.network_id
lb_dict['vip_subnet_id'] = db_lb.vip.subnet_id
return lb_dict
def _get_listener_in_pool_dict(self, pool_dict):
if 'listener' not in pool_dict:
if pool_dict.get('listener_id'):
db_listener = self.repositories.listener.get(
db_apis.get_session(), id=pool_dict['listener_id'])
listener_obj = oct_utils.db_listener_to_provider_listener(
db_listener)
listener_dict = listener_obj.to_dict(
recurse=False, render_unsets=True)
listener_dict['id'] = listener_dict['listener_id']
listener_dict['l7_policies'] = listener_dict['l7policies']
pool_dict['listener'] = listener_dict
if 'listeners' not in pool_dict:
# multiple listeners is not really supported yet
pool_dict['listeners'] = [listener_dict]
else:
pool_dict['listener'] = None
if 'listeners' not in pool_dict:
pool_dict['listeners'] = []
def _get_pool_dict(self, pool_id):
if not pool_id:
return
db_pool = self.repositories.pool.get(db_apis.get_session(), id=pool_id)
if not db_pool:
return
pool_obj = oct_utils.db_pool_to_provider_pool(db_pool)
pool_dict = pool_obj.to_dict(recurse=True, render_unsets=True)
pool_dict['id'] = pool_id
# Get the load balancer object
if pool_dict.get('loadbalancer_id'):
# Generate a loadbalancer object
pool_dict['loadbalancer'] = self._get_load_balancer_dict(
pool_dict['loadbalancer_id'])
if 'listener' not in pool_dict:
self._get_listener_in_pool_dict(pool_dict)
return pool_dict
def update_policy_dict(self, policy_dict, policy_obj, is_update=False):
if policy_dict.get('listener_id'):
db_list = self.repositories.listener.get(
db_apis.get_session(), id=policy_dict['listener_id'])
list_obj = oct_utils.db_listener_to_provider_listener(db_list)
list_dict = list_obj.to_dict(recurse=True, render_unsets=True)
list_dict['id'] = policy_dict['listener_id']
policy_dict['listener'] = list_dict
if policy_obj.rules:
policy_dict['rules'] = []
for rule in policy_obj.rules:
rule_dict = rule.to_dict(recurse=False, render_unsets=True)
rule_dict['id'] = rule_dict['l7rule_id']
policy_dict['rules'].append(rule_dict)
elif not is_update:
policy_dict['rules'] = []
def _remove_unsupported_keys(self, obj_type, obj_dict):
for key in unsupported_keys.get(obj_type, []):
if key in obj_dict:
if obj_dict.get(key):
LOG.warning("Ignoring %(key)s:%(val)s in %(type)s as the "
"NSX plugin does not currently support it",
{'key': key, 'val': obj_dict[key],
'type': obj_type})
del obj_dict[key]
def obj_to_dict(self, obj, is_update=False, project_id=None):
obj_type = obj.__class__.__name__
# create a dictionary out of the object
render_unsets = False if is_update else True
obj_dict = obj.to_dict(recurse=True, render_unsets=render_unsets)
# Update the dictionary to match what the nsx driver expects
if not project_id:
project_id = self.get_obj_project_id(obj_type, obj_dict)
obj_dict['tenant_id'] = obj_dict['project_id'] = project_id
if 'id' not in obj_dict:
obj_dict['id'] = obj_dict.get('%s_id' % obj_type.lower())
if not obj_dict.get('name') and not is_update:
obj_dict['name'] = ""
self._remove_unsupported_keys(obj_type, obj_dict)
if obj_type == 'LoadBalancer':
# clean listeners and pools for update case:
if 'listeners' in obj_dict:
if is_update and not obj_dict['listeners']:
del obj_dict['listeners']
else:
if obj_dict['listeners'] is None:
obj_dict['listeners'] = []
for listener in obj_dict['listeners']:
listener['id'] = listener['listener_id']
if 'pools' in obj_dict:
if is_update and not obj_dict['pools']:
del obj_dict['pools']
else:
if obj_dict['pools'] is None:
obj_dict['pools'] = []
for pool in obj_dict['pools']:
pool['id'] = pool['pool_id']
elif obj_type == 'Listener':
if 'l7policies' in obj_dict:
obj_dict['l7_policies'] = obj_dict['l7policies']
if obj_dict.get('loadbalancer_id'):
# Generate a loadbalancer object
obj_dict['loadbalancer'] = self._get_load_balancer_dict(
obj_dict['loadbalancer_id'])
# TODO(asarfaty): add default_tls_container_id
elif obj_type == 'Pool':
if 'listener' not in obj_dict:
self._get_listener_in_pool_dict(obj_dict)
elif obj_type == 'Member':
# Get the pool object
if obj_dict.get('pool_id'):
obj_dict['pool'] = self._get_pool_dict(obj_dict['pool_id'])
obj_dict['loadbalancer'] = None
if 'loadbalancer' in obj_dict['pool']:
obj_dict['loadbalancer'] = obj_dict['pool']['loadbalancer']
if not obj_dict.get('subnet_id'):
# Use the parent vip_subnet_id instead
obj_dict['subnet_id'] = obj_dict['loadbalancer'][
'vip_subnet_id']
else:
obj_dict['pool'] = None
obj_dict['loadbalancer'] = None
elif obj_type == 'HealthMonitor':
# Get the pool object
if obj_dict.get('pool_id'):
obj_dict['pool'] = self._get_pool_dict(obj_dict['pool_id'])
elif obj_type == 'L7Policy':
self.update_policy_dict(obj_dict, obj, is_update=is_update)
elif obj_type == 'L7Rule':
# Get the L7 policy object
if obj_dict.get('l7policy_id'):
db_policy = self.repositories.l7policy.get(
db_apis.get_session(), id=obj_dict['l7policy_id'])
policy_obj = oct_utils.db_l7policy_to_provider_l7policy(
db_policy)
policy_dict = policy_obj.to_dict(
recurse=True, render_unsets=True)
policy_dict['id'] = obj_dict['l7policy_id']
self.update_policy_dict(
policy_dict, policy_obj, is_update=is_update)
obj_dict['policy'] = policy_dict
LOG.debug("Translated %(type)s to dictionary: %(obj)s",
{'type': obj_type, 'obj': obj_dict})
return obj_dict
# Load Balancer
@log_helpers.log_method_call
def create_vip_port(self, loadbalancer_id, project_id, vip_dictionary):
raise exceptions.NotImplementedError()
@log_helpers.log_method_call
def loadbalancer_create(self, loadbalancer):
kw = {'loadbalancer': self.obj_to_dict(loadbalancer)}
self.client.cast({}, 'loadbalancer_create', **kw)
@log_helpers.log_method_call
def loadbalancer_delete(self, loadbalancer, cascade=False):
if cascade:
# TODO(asarfaty) add support for cascade
LOG.warning("The NSX Octavia driver does not support loadbalancer "
"delete cascade")
raise exceptions.NotImplementedError()
kw = {'loadbalancer': self.obj_to_dict(loadbalancer),
'cascade': cascade}
self.client.cast({}, 'loadbalancer_delete', **kw)
@log_helpers.log_method_call
def loadbalancer_failover(self, loadbalancer_id):
LOG.error('Loadbalancer failover is handled by platform')
raise exceptions.NotImplementedError()
@log_helpers.log_method_call
def loadbalancer_update(self, old_loadbalancer, new_loadbalancer):
old_dict = self.obj_to_dict(old_loadbalancer)
new_dict = copy.deepcopy(old_dict)
new_dict.update(self.obj_to_dict(
new_loadbalancer, is_update=True,
project_id=old_dict.get('project_id')))
kw = {'old_loadbalancer': old_dict,
'new_loadbalancer': new_dict}
self.client.cast({}, 'loadbalancer_update', **kw)
# Listener
@log_helpers.log_method_call
def listener_create(self, listener):
cert = None
dict_list = self.obj_to_dict(listener)
if dict_list.get('tls_certificate_id'):
context = pecan.request.context.get('octavia_context')
cert = self.cert_manager.get_cert(context,
dict_list['tls_certificate_id'])
kw = {'listener': dict_list, 'cert': cert}
self.client.cast({}, 'listener_create', **kw)
@log_helpers.log_method_call
def listener_delete(self, listener):
kw = {'listener': self.obj_to_dict(listener)}
self.client.cast({}, 'listener_delete', **kw)
@log_helpers.log_method_call
def listener_update(self, old_listener, new_listener):
old_dict = self.obj_to_dict(old_listener)
new_dict = copy.deepcopy(old_dict)
new_dict.update(self.obj_to_dict(
new_listener, is_update=True,
project_id=old_dict.get('project_id')))
cert = None
if new_dict.get('tls_certificate_id'):
context = pecan.request.context.get('octavia_context')
cert = self.cert_manager.get_cert(context,
new_dict['tls_certificate_id'])
kw = {'old_listener': old_dict,
'new_listener': new_dict,
'cert': cert}
self.client.cast({}, 'listener_update', **kw)
# Pool
@log_helpers.log_method_call
def pool_create(self, pool):
kw = {'pool': self.obj_to_dict(pool)}
self.client.cast({}, 'pool_create', **kw)
@log_helpers.log_method_call
def pool_delete(self, pool):
kw = {'pool': self.obj_to_dict(pool)}
self.client.cast({}, 'pool_delete', **kw)
@log_helpers.log_method_call
def pool_update(self, old_pool, new_pool):
old_dict = self.obj_to_dict(old_pool)
new_dict = copy.deepcopy(old_dict)
new_dict.update(self.obj_to_dict(
new_pool, is_update=True, project_id=old_dict.get('project_id')))
kw = {'old_pool': old_dict,
'new_pool': new_dict}
self.client.cast({}, 'pool_update', **kw)
# Member
@log_helpers.log_method_call
def member_create(self, member):
kw = {'member': self.obj_to_dict(member)}
self.client.cast({}, 'member_create', **kw)
@log_helpers.log_method_call
def member_delete(self, member):
kw = {'member': self.obj_to_dict(member)}
self.client.cast({}, 'member_delete', **kw)
@log_helpers.log_method_call
def member_update(self, old_member, new_member):
old_dict = self.obj_to_dict(old_member)
new_dict = copy.deepcopy(old_dict)
new_dict.update(self.obj_to_dict(
new_member, is_update=True, project_id=old_dict.get('project_id')))
kw = {'old_member': old_dict,
'new_member': new_dict}
self.client.cast({}, 'member_update', **kw)
@log_helpers.log_method_call
def member_batch_update(self, members):
raise NotImplementedError()
# Health Monitor
@log_helpers.log_method_call
def health_monitor_create(self, healthmonitor):
kw = {'healthmonitor': self.obj_to_dict(healthmonitor)}
self.client.cast({}, 'healthmonitor_create', **kw)
@log_helpers.log_method_call
def health_monitor_delete(self, healthmonitor):
kw = {'healthmonitor': self.obj_to_dict(healthmonitor)}
self.client.cast({}, 'healthmonitor_delete', **kw)
@log_helpers.log_method_call
def health_monitor_update(self, old_healthmonitor, new_healthmonitor):
old_dict = self.obj_to_dict(old_healthmonitor)
new_dict = copy.deepcopy(old_dict)
new_dict.update(self.obj_to_dict(
new_healthmonitor, is_update=True,
project_id=old_dict.get('project_id')))
kw = {'old_healthmonitor': old_dict,
'new_healthmonitor': new_dict}
self.client.cast({}, 'healthmonitor_update', **kw)
# L7 Policy
@log_helpers.log_method_call
def l7policy_create(self, l7policy):
kw = {'l7policy': self.obj_to_dict(l7policy)}
self.client.cast({}, 'l7policy_create', **kw)
@log_helpers.log_method_call
def l7policy_delete(self, l7policy):
kw = {'l7policy': self.obj_to_dict(l7policy)}
self.client.cast({}, 'l7policy_delete', **kw)
@log_helpers.log_method_call
def l7policy_update(self, old_l7policy, new_l7policy):
old_dict = self.obj_to_dict(old_l7policy)
new_dict = copy.deepcopy(old_dict)
new_dict.update(self.obj_to_dict(
new_l7policy, is_update=True,
project_id=old_dict.get('project_id')))
kw = {'old_l7policy': old_dict,
'new_l7policy': new_dict}
self.client.cast({}, 'l7policy_update', **kw)
# L7 Rule
@log_helpers.log_method_call
def l7rule_create(self, l7rule):
kw = {'l7rule': self.obj_to_dict(l7rule)}
self.client.cast({}, 'l7rule_create', **kw)
@log_helpers.log_method_call
def l7rule_delete(self, l7rule):
kw = {'l7rule': self.obj_to_dict(l7rule)}
self.client.cast({}, 'l7rule_delete', **kw)
@log_helpers.log_method_call
def l7rule_update(self, old_l7rule, new_l7rule):
old_dict = self.obj_to_dict(old_l7rule)
new_dict = copy.deepcopy(old_dict)
new_dict.update(self.obj_to_dict(
new_l7rule, is_update=True, project_id=old_dict.get('project_id')))
kw = {'old_l7rule': old_dict,
'new_l7rule': new_dict}
self.client.cast({}, 'l7rule_update', **kw)
# Flavor
@log_helpers.log_method_call
def get_supported_flavor_metadata(self):
raise exceptions.NotImplementedError()
@log_helpers.log_method_call
def validate_flavor(self, flavor_metadata):
raise exceptions.NotImplementedError()
class NSXOctaviaDriverEndpoint(driver_lib.DriverLibrary):
target = messaging.Target(namespace="control", version='1.0')
@log_helpers.log_method_call
def update_loadbalancer_status(self, ctxt, status):
return super(NSXOctaviaDriverEndpoint,
self).update_loadbalancer_status(status)
@log_helpers.log_method_call
def update_listener_statistics(self, ctxt, statistics):
return super(NSXOctaviaDriverEndpoint,
self).update_listener_statistics(statistics)

368
vmware_nsx/services/lbaas/octavia/octavia_listener.py Normal file
View File

@ -0,0 +1,368 @@
# Copyright 2018 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 socket
import time
import eventlet
from neutron_lib import context as neutron_context
from oslo_config import cfg
from oslo_log import helpers as log_helpers
from oslo_log import log as logging
import oslo_messaging as messaging
from oslo_messaging.rpc import dispatcher
from neutron_lbaas.db.loadbalancer import models
from vmware_nsx.services.lbaas.octavia import constants
LOG = logging.getLogger(__name__)
class NSXOctaviaListener(object):
@log_helpers.log_method_call
def __init__(self, loadbalancer=None, listener=None, pool=None,
member=None, healthmonitor=None, l7policy=None, l7rule=None):
self._init_rpc_messaging()
self._init_rpc_listener(healthmonitor, l7policy, l7rule, listener,
loadbalancer, member, pool)
def _init_rpc_messaging(self):
topic = constants.DRIVER_TO_OCTAVIA_TOPIC
transport = messaging.get_rpc_transport(cfg.CONF)
target = messaging.Target(topic=topic, exchange="common",
namespace='control', fanout=False,
version='1.0')
self.client = messaging.RPCClient(transport, target)
def _init_rpc_listener(self, healthmonitor, l7policy, l7rule, listener,
loadbalancer, member, pool):
# Initialize RPC listener
topic = constants.OCTAVIA_TO_DRIVER_TOPIC
server = socket.gethostname()
transport = messaging.get_rpc_transport(cfg.CONF)
target = messaging.Target(topic=topic, server=server,
exchange="common", fanout=False)
self.endpoints = [NSXOctaviaListenerEndpoint(
client=self.client, loadbalancer=loadbalancer, listener=listener,
pool=pool, member=member, healthmonitor=healthmonitor,
l7policy=l7policy, l7rule=l7rule)]
access_policy = dispatcher.DefaultRPCAccessPolicy
self.octavia_server = messaging.get_rpc_server(
transport, target, self.endpoints, executor='eventlet',
access_policy=access_policy)
self.octavia_server.start()
class NSXOctaviaListenerEndpoint(object):
target = messaging.Target(namespace="control", version='1.0')
def __init__(self, client=None, loadbalancer=None, listener=None,
pool=None, member=None, healthmonitor=None, l7policy=None,
l7rule=None):
self.client = client
self.loadbalancer = loadbalancer
self.listener = listener
self.pool = pool
self.member = member
self.healthmonitor = healthmonitor
self.l7policy = l7policy
self.l7rule = l7rule
def get_completor_func(self, obj_type, obj, delete=False):
# return a method that will be called on success/failure completion
def completor_func(success=True):
LOG.debug("Octavia transaction completed. status %s",
'success' if success else 'failure')
# calculate the provisioning and operating statuses
main_prov_status = constants.ACTIVE
parent_prov_status = constants.ACTIVE
if not success:
main_prov_status = constants.ERROR
parent_prov_status = constants.ERROR
elif delete:
main_prov_status = constants.DELETED
op_status = constants.ONLINE if success else constants.ERROR
# add the status of the created/deleted/updated object
status_dict = {
obj_type: [{
'id': obj['id'],
constants.PROVISIONING_STATUS: main_prov_status,
constants.OPERATING_STATUS: op_status}]}
# Get all its parents, and update their statuses as well
loadbalancer_id = None
listener_id = None
pool_id = None
policy_id = None
if obj_type != constants.LOADBALANCERS:
loadbalancer_id = None
if obj.get('loadbalancer_id'):
loadbalancer_id = obj.get('loadbalancer_id')
elif obj.get('pool'):
pool_id = obj['pool']['id']
loadbalancer_id = obj['pool']['loadbalancer_id']
elif obj.get('listener'):
listener_id = obj['listener']['id']
loadbalancer_id = obj['listener']['loadbalancer_id']
elif obj.get('policy') and obj['policy'].get('listener'):
policy_id = obj['policy']['id']
listener_id = obj['policy']['listener']['id']
loadbalancer_id = obj['policy']['listener'][
'loadbalancer_id']
if loadbalancer_id:
status_dict[constants.LOADBALANCERS] = [{
'id': loadbalancer_id,
constants.PROVISIONING_STATUS: parent_prov_status,
constants.OPERATING_STATUS: op_status}]
if listener_id:
status_dict[constants.LISTENERS] = [{
'id': listener_id,
constants.PROVISIONING_STATUS: parent_prov_status,
constants.OPERATING_STATUS: op_status}]
if pool_id:
status_dict[constants.POOLS] = [{
'id': pool_id,
constants.PROVISIONING_STATUS: parent_prov_status,
constants.OPERATING_STATUS: op_status}]
if policy_id:
status_dict[constants.L7POLICIES] = [{
'id': policy_id,
constants.PROVISIONING_STATUS: parent_prov_status,
constants.OPERATING_STATUS: op_status}]
kw = {'status': status_dict}
self.client.cast({}, 'update_loadbalancer_status', **kw)
return completor_func
def update_listener_statistics(self, statistics):
kw = {'statistics': statistics}
self.client.cast({}, 'update_listener_statistics', **kw)
@log_helpers.log_method_call
def loadbalancer_create(self, ctxt, loadbalancer):
ctx = neutron_context.Context(None, loadbalancer['project_id'])
self.loadbalancer.create(
ctx, loadbalancer,
self.get_completor_func(constants.LOADBALANCERS,
loadbalancer))
@log_helpers.log_method_call
def loadbalancer_delete(self, ctxt, loadbalancer, cascade=False):
ctx = neutron_context.Context(None, loadbalancer['project_id'])
# TODO(asarfaty): No support for cascade. It is blocked by the driver
self.loadbalancer.delete(
ctx, loadbalancer,
self.get_completor_func(constants.LOADBALANCERS,
loadbalancer,
delete=True))
@log_helpers.log_method_call
def loadbalancer_update(self, ctxt, old_loadbalancer, new_loadbalancer):
ctx = neutron_context.Context(None, old_loadbalancer['project_id'])
self.loadbalancer.update(
ctx, old_loadbalancer, new_loadbalancer,
self.get_completor_func(constants.LOADBALANCERS,
new_loadbalancer))
# Listener
@log_helpers.log_method_call
def listener_create(self, ctxt, listener, cert):
ctx = neutron_context.Context(None, listener['project_id'])
self.listener.create(ctx, listener,
self.get_completor_func(constants.LISTENERS,
listener),
certificate=cert)
@log_helpers.log_method_call
def listener_delete(self, ctxt, listener):
ctx = neutron_context.Context(None, listener['project_id'])
self.listener.delete(ctx, listener,
self.get_completor_func(constants.LISTENERS,
listener,
delete=True))
@log_helpers.log_method_call
def listener_update(self, ctxt, old_listener, new_listener, cert):
ctx = neutron_context.Context(None, old_listener['project_id'])
self.listener.update(ctx, old_listener, new_listener,
self.get_completor_func(constants.LISTENERS,
new_listener),
certificate=cert)
# Pool
@log_helpers.log_method_call
def pool_create(self, ctxt, pool):
ctx = neutron_context.Context(None, pool['project_id'])
self.pool.create(ctx, pool, self.get_completor_func(constants.POOLS,
pool))
@log_helpers.log_method_call
def pool_delete(self, ctxt, pool):
ctx = neutron_context.Context(None, pool['project_id'])
self.pool.delete(ctx, pool, self.get_completor_func(constants.POOLS,
pool,
delete=True))
@log_helpers.log_method_call
def pool_update(self, ctxt, old_pool, new_pool):
ctx = neutron_context.Context(None, old_pool['project_id'])
self.pool.update(ctx, old_pool, new_pool,
self.get_completor_func(constants.POOLS, new_pool))
# Member
@log_helpers.log_method_call
def member_create(self, ctxt, member):
ctx = neutron_context.Context(None, member['project_id'])
self.member.create(ctx, member,
self.get_completor_func(constants.MEMBERS,
member))
@log_helpers.log_method_call
def member_delete(self, ctxt, member):
ctx = neutron_context.Context(None, member['project_id'])
self.member.delete(ctx, member,
self.get_completor_func(constants.MEMBERS,
member,
delete=True))
@log_helpers.log_method_call
def member_update(self, ctxt, old_member, new_member):
ctx = neutron_context.Context(None, old_member['project_id'])
self.member.update(ctx, old_member, new_member,
self.get_completor_func(constants.MEMBERS,
new_member))
# Health Monitor
@log_helpers.log_method_call
def healthmonitor_create(self, ctxt, healthmonitor):
ctx = neutron_context.Context(None, healthmonitor['project_id'])
self.healthmonitor.create(ctx, healthmonitor,
self.get_completor_func(
constants.HEALTHMONITORS, healthmonitor))
@log_helpers.log_method_call
def healthmonitor_delete(self, ctxt, healthmonitor):
ctx = neutron_context.Context(None, healthmonitor['project_id'])
self.healthmonitor.delete(ctx, healthmonitor,
self.get_completor_func(
constants.HEALTHMONITORS, healthmonitor,
delete=True))
@log_helpers.log_method_call
def healthmonitor_update(self, ctxt, old_healthmonitor, new_healthmonitor):
ctx = neutron_context.Context(None, old_healthmonitor['project_id'])
self.healthmonitor.update(ctx, old_healthmonitor, new_healthmonitor,
self.get_completor_func(
constants.HEALTHMONITORS,
new_healthmonitor))
# L7 Policy
@log_helpers.log_method_call
def l7policy_create(self, ctxt, l7policy):
ctx = neutron_context.Context(None, l7policy['project_id'])
self.l7policy.create(ctx, l7policy,
self.get_completor_func(constants.L7POLICIES,
l7policy))
@log_helpers.log_method_call
def l7policy_delete(self, ctxt, l7policy):
ctx = neutron_context.Context(None, l7policy['project_id'])
self.l7policy.delete(ctx, l7policy,
self.get_completor_func(constants.L7POLICIES,
l7policy,
delete=True))
@log_helpers.log_method_call
def l7policy_update(self, ctxt, old_l7policy, new_l7policy):
ctx = neutron_context.Context(None, old_l7policy['project_id'])
self.l7policy.update(ctx, old_l7policy, new_l7policy,
self.get_completor_func(constants.L7POLICIES,
new_l7policy))
# L7 Rule
@log_helpers.log_method_call
def l7rule_create(self, ctxt, l7rule):
ctx = neutron_context.Context(None, l7rule['project_id'])
self.l7rule.create(ctx, l7rule,
self.get_completor_func(constants.L7RULES, l7rule))
@log_helpers.log_method_call
def l7rule_delete(self, ctxt, l7rule):
ctx = neutron_context.Context(None, l7rule['project_id'])
self.l7rule.delete(ctx, l7rule,
self.get_completor_func(constants.L7RULES,
l7rule,
delete=True))
@log_helpers.log_method_call
def l7rule_update(self, ctxt, old_l7rule, new_l7rule):
ctx = neutron_context.Context(None, old_l7rule['project_id'])
self.l7rule.update(ctx, old_l7rule, new_l7rule,
self.get_completor_func(constants.L7RULES,
new_l7rule))
class NSXOctaviaStatisticsCollector(object):
def __init__(self, core_plugin, listener_stats_getter):
self.core_plugin = core_plugin
self.listener_stats_getter = listener_stats_getter
if cfg.CONF.octavia_stats_interval:
eventlet.spawn_n(self.thread_runner,
cfg.CONF.octavia_stats_interval)
@log_helpers.log_method_call
def thread_runner(self, interval):
while True:
time.sleep(interval)
self.collect()
def _get_nl_loadbalancers(self, context):
"""Getting the list of neutron-lbaas loadbalancers
This is done directly from the neutron-lbaas DB to also support the
case that the plugin is currently unavailable, but entries already
exist on the DB.
"""
nl_loadbalancers = context.session.query(models.LoadBalancer).all()
return [lb.id for lb in nl_loadbalancers]
@log_helpers.log_method_call
def collect(self):
if not self.core_plugin.octavia_listener:
return
endpoint = self.core_plugin.octavia_listener.endpoints[0]
context = neutron_context.get_admin_context()
# get the statistics of all the Octavia loadbalancers/listeners while
# ignoring the neutron-lbaas loadbalancers.
# Note(asarfaty): The Octavia plugin/DB is unavailable from the
# neutron context, so there is no option to query the Octavia DB for
# the relevant loadbalancers.
nl_loadbalancers = self._get_nl_loadbalancers(context)
listeners_stats = self.listener_stats_getter(
context, self.core_plugin, ignore_list=nl_loadbalancers)
if not listeners_stats:
# Avoid sending empty stats
return
stats = {'listeners': listeners_stats}
endpoint.update_listener_statistics(stats)

3
vmware_nsx/tests/unit/services/lbaas/test_nsxv3_driver.py
View File

@ -293,7 +293,8 @@ class TestEdgeLbaasV2Loadbalancer(BaseTestEdgeLbaasV2):
) as mock_get_pool_binding, \
mock.patch.object(self.pool_client, 'get'
) as mock_get_pool, \
mock.patch.object(nsx_db, 'get_nsx_lbaas_listener_binding_by_vs'
mock.patch.object(nsx_db,
'get_nsx_lbaas_listener_binding_by_lb_and_vs'
) as mock_get_listener_binding:
mock_get_lb_binding.return_value = LB_BINDING
mock_get_pool_binding.return_value = POOL_BINDING

477
vmware_nsx/tests/unit/services/lbaas/test_octavia_driver.py Normal file
View File

@ -0,0 +1,477 @@
# Copyright 2018 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 decorator
import mock
import testtools
from oslo_utils import uuidutils
code_ok = True
# Skip duplications between Octavia & Neutron configurations
with mock.patch('oslo_config.cfg.ConfigOpts.import_group'):
try:
from octavia.api.drivers import data_models
from vmware_nsx.services.lbaas.octavia import octavia_driver as driver
except ImportError:
# Octavia code not found
# this can happen as Octavia is not in the requirements yet
code_ok = False
DRIVER = 'vmware_nsx.services.lbaas.octavia.octavia_driver.NSXOctaviaDriver'
class TestNsxProviderDriver(testtools.TestCase):
"""Test the NSX Octavia driver
Make sure all the relevant data is translated and sent to the listener
"""
def setUp(self):
super(TestNsxProviderDriver, self).setUp()
global code_ok
if not code_ok:
return
# init the NSX driver without the RPC & certificate
with mock.patch(DRIVER + '._init_rpc_messaging'), \
mock.patch(DRIVER + '._init_rpc_listener'), \
mock.patch(DRIVER + '._init_cert_manager'):
self.driver = driver.NSXOctaviaDriver()
self.driver.client = mock.Mock()
self.loadbalancer_id = uuidutils.generate_uuid()
self.vip_address = '192.0.2.10'
self.vip_network_id = uuidutils.generate_uuid()
self.vip_port_id = uuidutils.generate_uuid()
self.vip_subnet_id = uuidutils.generate_uuid()
self.listener_id = uuidutils.generate_uuid()
self.pool_id = uuidutils.generate_uuid()
self.member_id = uuidutils.generate_uuid()
self.member_subnet_id = uuidutils.generate_uuid()
self.healthmonitor_id = uuidutils.generate_uuid()
self.l7policy_id = uuidutils.generate_uuid()
self.l7rule_id = uuidutils.generate_uuid()
self.project_id = uuidutils.generate_uuid()
self.default_tls_container_ref = uuidutils.generate_uuid()
self.sni_container_ref_1 = uuidutils.generate_uuid()
self.sni_container_ref_2 = uuidutils.generate_uuid()
self.ref_member = data_models.Member(
address='198.51.100.4',
admin_state_up=True,
member_id=self.member_id,
monitor_address='203.0.113.2',
monitor_port=66,
name='jacket',
pool_id=self.pool_id,
protocol_port=99,
subnet_id=self.member_subnet_id,
weight=55)
self.ref_healthmonitor = data_models.HealthMonitor(
admin_state_up=False,
delay=2,
expected_codes="500",
healthmonitor_id=self.healthmonitor_id,
http_method='TRACE',
max_retries=1,
max_retries_down=0,
name='doc',
pool_id=self.pool_id,
timeout=3,
type='PHD',
url_path='/index.html')
self.ref_pool = data_models.Pool(
admin_state_up=True,
description='Olympic swimming pool',
healthmonitor=self.ref_healthmonitor,
lb_algorithm='A_Fast_One',
loadbalancer_id=self.loadbalancer_id,
members=[self.ref_member],
name='Osborn',
pool_id=self.pool_id,
protocol='avian',
session_persistence={'type': 'glue'})
self.ref_l7rule = data_models.L7Rule(
admin_state_up=True,
compare_type='store_brand',
invert=True,
key='board',
l7policy_id=self.l7policy_id,
l7rule_id=self.l7rule_id,
type='strict',
value='gold')
self.ref_l7policy = data_models.L7Policy(
action='packed',
admin_state_up=False,
description='Corporate policy',
l7policy_id=self.l7policy_id,
listener_id=self.listener_id,
name='more_policy',
position=1,
redirect_pool_id=self.pool_id,
redirect_url='/hr',
rules=[self.ref_l7rule])
self.ref_listener = data_models.Listener(
admin_state_up=False,
connection_limit=5,
default_pool=self.ref_pool,
default_pool_id=self.pool_id,
default_tls_container_data='default_cert_data',
default_tls_container_ref=self.default_tls_container_ref,
description='The listener',
insert_headers={'X-Forwarded-For': 'true'},
l7policies=[self.ref_l7policy],
listener_id=self.listener_id,
loadbalancer_id=self.loadbalancer_id,
name='super_listener',
protocol='avian',
protocol_port=42,
sni_container_data=['sni_cert_data_1', 'sni_cert_data_2'],
sni_container_refs=[self.sni_container_ref_1,
self.sni_container_ref_2])
self.ref_lb = data_models.LoadBalancer(
admin_state_up=False,
description='One great load balancer',
flavor={'cake': 'chocolate'},
listeners=[self.ref_listener],
loadbalancer_id=self.loadbalancer_id,
name='favorite_lb',
project_id=self.project_id,
vip_address=self.vip_address,
vip_network_id=self.vip_network_id,
vip_port_id=self.vip_port_id,
vip_subnet_id=self.vip_subnet_id)
# start DB mocks
mock.patch('octavia.db.api.get_session').start()
mock.patch("octavia.api.drivers.utils.db_pool_to_provider_pool",
return_value=self.ref_pool).start()
@decorator.decorator
def skip_no_octavia(f, *args, **kwargs):
global code_ok
if not code_ok:
obj = args[0]
return obj.skipTest('Octavia code not found')
return f(*args, **kwargs)
@skip_no_octavia
def test_loadbalancer_create(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.loadbalancer_create(self.ref_lb)
cast_method.assert_called_with({}, 'loadbalancer_create',
loadbalancer=mock.ANY)
driver_obj = cast_method.call_args[1]['loadbalancer']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
self.assertIn('admin_state_up', driver_obj)
self.assertIn('name', driver_obj)
self.assertIn('listeners', driver_obj)
self.assertEqual(1, len(driver_obj['listeners']))
self.assertEqual(self.ref_lb.vip_address,
driver_obj['vip_address'])
self.assertEqual(self.ref_lb.vip_network_id,
driver_obj['vip_network_id'])
self.assertEqual(self.ref_lb.vip_port_id,
driver_obj['vip_port_id'])
self.assertEqual(self.ref_lb.vip_subnet_id,
driver_obj['vip_subnet_id'])
@skip_no_octavia
def test_loadbalancer_delete(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.loadbalancer_delete(self.ref_lb)
cast_method.assert_called_with({}, 'loadbalancer_delete',
cascade=False,
loadbalancer=mock.ANY)
driver_obj = cast_method.call_args[1]['loadbalancer']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
@skip_no_octavia
def test_loadbalancer_update(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.loadbalancer_update(self.ref_lb, self.ref_lb)
cast_method.assert_called_with({}, 'loadbalancer_update',
old_loadbalancer=mock.ANY,
new_loadbalancer=mock.ANY)
driver_obj = cast_method.call_args[1]['new_loadbalancer']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
@skip_no_octavia
def test_listener_create(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.listener_create(self.ref_listener)
cast_method.assert_called_with({}, 'listener_create', cert=None,
listener=mock.ANY)
driver_obj = cast_method.call_args[1]['listener']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
self.assertIn('admin_state_up', driver_obj)
self.assertIn('name', driver_obj)
self.assertIn('loadbalancer_id', driver_obj)
self.assertIn('loadbalancer', driver_obj)
self.assertEqual(self.ref_listener.protocol,
driver_obj['protocol'])
self.assertEqual(self.ref_listener.protocol_port,
driver_obj['protocol_port'])
self.assertEqual(self.ref_listener.connection_limit,
driver_obj['connection_limit'])
self.assertIn('l7policies', driver_obj)
#TODO(asarfaty) add after the driver is fixed
#self.assertIn('default_tls_container_id', driver_obj)
@skip_no_octavia
def test_listener_delete(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.listener_delete(self.ref_listener)
cast_method.assert_called_with({}, 'listener_delete',
listener=mock.ANY)
driver_obj = cast_method.call_args[1]['listener']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
@skip_no_octavia
def test_listener_update(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.listener_update(self.ref_listener, self.ref_listener)
cast_method.assert_called_with({}, 'listener_update', cert=None,
old_listener=mock.ANY,
new_listener=mock.ANY)
driver_obj = cast_method.call_args[1]['new_listener']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
@skip_no_octavia
def test_pool_create(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.pool_create(self.ref_pool)
cast_method.assert_called_with({}, 'pool_create', pool=mock.ANY)
driver_obj = cast_method.call_args[1]['pool']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
self.assertIn('admin_state_up', driver_obj)
self.assertIn('name', driver_obj)
self.assertIn('loadbalancer_id', driver_obj)
self.assertIn('listener', driver_obj)
self.assertIn('listeners', driver_obj)
self.assertEqual(self.ref_pool.lb_algorithm,
driver_obj['lb_algorithm'])
self.assertEqual(self.ref_pool.session_persistence,
driver_obj['session_persistence'])
self.assertIn('members', driver_obj)
@skip_no_octavia
def test_pool_delete(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.pool_delete(self.ref_pool)
cast_method.assert_called_with({}, 'pool_delete', pool=mock.ANY)
driver_obj = cast_method.call_args[1]['pool']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
@skip_no_octavia
def test_pool_update(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.pool_update(self.ref_pool, self.ref_pool)
cast_method.assert_called_with({}, 'pool_update',
old_pool=mock.ANY,
new_pool=mock.ANY)
driver_obj = cast_method.call_args[1]['new_pool']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
@skip_no_octavia
def test_member_create(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.member_create(self.ref_member)
cast_method.assert_called_with({}, 'member_create',
member=mock.ANY)
driver_obj = cast_method.call_args[1]['member']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
self.assertIn('admin_state_up', driver_obj)
self.assertIn('name', driver_obj)
self.assertEqual(self.pool_id, driver_obj['pool_id'])
self.assertIn('pool', driver_obj)
self.assertIn('loadbalancer', driver_obj['pool'])
#TODO(asarfaty) add when the driver is fixed
#self.assertIn('listener', driver_obj['pool'])
self.assertEqual(self.ref_member.subnet_id,
driver_obj['subnet_id'])
self.assertEqual(self.ref_member.address,
driver_obj['address'])
self.assertEqual(self.ref_member.protocol_port,
driver_obj['protocol_port'])
self.assertEqual(self.ref_member.weight,
driver_obj['weight'])
@skip_no_octavia
def test_member_delete(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.member_delete(self.ref_member)
cast_method.assert_called_with({}, 'member_delete',
member=mock.ANY)
driver_obj = cast_method.call_args[1]['member']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
@skip_no_octavia
def test_member_update(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.member_update(self.ref_member, self.ref_member)
cast_method.assert_called_with({}, 'member_update',
old_member=mock.ANY,
new_member=mock.ANY)
driver_obj = cast_method.call_args[1]['old_member']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
@skip_no_octavia
def test_health_monitor_create(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.health_monitor_create(self.ref_healthmonitor)
cast_method.assert_called_with({}, 'healthmonitor_create',
healthmonitor=mock.ANY)
driver_obj = cast_method.call_args[1]['healthmonitor']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
self.assertIn('admin_state_up', driver_obj)
self.assertIn('name', driver_obj)
self.assertEqual(self.ref_healthmonitor.type,
driver_obj['type'])
self.assertEqual(self.ref_healthmonitor.url_path,
driver_obj['url_path'])
self.assertEqual(self.ref_healthmonitor.delay,
driver_obj['delay'])
self.assertEqual(self.ref_healthmonitor.timeout,
driver_obj['timeout'])
self.assertEqual(self.ref_healthmonitor.max_retries,
driver_obj['max_retries'])
self.assertEqual(self.ref_healthmonitor.http_method,
driver_obj['http_method'])
self.assertIn('pool', driver_obj)
self.assertEqual(self.pool_id,
driver_obj['pool']['id'])
self.assertEqual(self.loadbalancer_id,
driver_obj['pool']['loadbalancer_id'])
@skip_no_octavia
def test_health_monitor_delete(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.health_monitor_delete(self.ref_healthmonitor)
cast_method.assert_called_with({}, 'healthmonitor_delete',
healthmonitor=mock.ANY)
driver_obj = cast_method.call_args[1]['healthmonitor']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
@skip_no_octavia
def test_health_monitor_update(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.health_monitor_update(self.ref_healthmonitor,
self.ref_healthmonitor)
cast_method.assert_called_with({}, 'healthmonitor_update',
old_healthmonitor=mock.ANY,
new_healthmonitor=mock.ANY)
driver_obj = cast_method.call_args[1]['new_healthmonitor']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
@skip_no_octavia
def test_l7policy_create(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.l7policy_create(self.ref_l7policy)
cast_method.assert_called_with({}, 'l7policy_create',
l7policy=mock.ANY)
driver_obj = cast_method.call_args[1]['l7policy']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
self.assertIn('admin_state_up', driver_obj)
self.assertIn('name', driver_obj)
self.assertIn('listener', driver_obj)
self.assertEqual(self.listener_id, driver_obj['listener_id'])
self.assertIn('rules', driver_obj)
self.assertIn('position', driver_obj)
self.assertEqual(self.ref_l7policy.action, driver_obj['action'])
self.assertEqual(self.ref_l7policy.redirect_url,
driver_obj['redirect_url'])
self.assertEqual(self.ref_l7policy.redirect_pool_id,
driver_obj['redirect_pool_id'])
@skip_no_octavia
def test_l7policy_delete(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.l7policy_delete(self.ref_l7policy)
cast_method.assert_called_with({}, 'l7policy_delete',
l7policy=mock.ANY)
driver_obj = cast_method.call_args[1]['l7policy']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
@skip_no_octavia
def test_l7policy_update(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.l7policy_update(self.ref_l7policy, self.ref_l7policy)
cast_method.assert_called_with({}, 'l7policy_update',
old_l7policy=mock.ANY,
new_l7policy=mock.ANY)
driver_obj = cast_method.call_args[1]['new_l7policy']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
@skip_no_octavia
def test_l7rule_create(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.l7rule_create(self.ref_l7rule)
cast_method.assert_called_with({}, 'l7rule_create',
l7rule=mock.ANY)
driver_obj = cast_method.call_args[1]['l7rule']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
self.assertIn('admin_state_up', driver_obj)
self.assertIn('name', driver_obj)
self.assertIn('policy', driver_obj)
self.assertIn('rules', driver_obj['policy'])
self.assertEqual(self.ref_l7rule.type, driver_obj['type'])
self.assertEqual(self.ref_l7rule.value, driver_obj['value'])
self.assertEqual(self.ref_l7rule.invert, driver_obj['invert'])
@skip_no_octavia
def test_l7rule_delete(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.l7rule_delete(self.ref_l7rule)
cast_method.assert_called_with({}, 'l7rule_delete',
l7rule=mock.ANY)
driver_obj = cast_method.call_args[1]['l7rule']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)
@skip_no_octavia
def test_l7rule_update(self):
with mock.patch.object(self.driver.client, 'cast') as cast_method:
self.driver.l7rule_update(self.ref_l7rule, self.ref_l7rule)
cast_method.assert_called_with({}, 'l7rule_update',
old_l7rule=mock.ANY,
new_l7rule=mock.ANY)
driver_obj = cast_method.call_args[1]['new_l7rule']
self.assertIn('id', driver_obj)
self.assertIn('project_id', driver_obj)

301
vmware_nsx/tests/unit/services/lbaas/test_octavia_listener.py Normal file
View File

@ -0,0 +1,301 @@
# Copyright 2018 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
import testtools
from oslo_utils import uuidutils
from vmware_nsx.services.lbaas.octavia import octavia_listener
class DummyOctaviaResource(object):
create_called = False
update_called = False
delete_called = False
def create(self, ctx, lb_obj, completor_func, **args):
self.create_called = True
completor_func(success=True)
def update(self, ctx, old_lb_obj, new_lb_obj, completor_func, **args):
self.update_called = True
completor_func(success=True)
def delete(self, ctx, lb_obj, completor_func, **args):
self.delete_called = True
completor_func(success=True)
class TestNsxOctaviaListener(testtools.TestCase):
"""Test the NSX Octavia listener"""
def setUp(self):
super(TestNsxOctaviaListener, self).setUp()
self.dummyResource = DummyOctaviaResource()
self.clientMock = mock.Mock()
self.clientMock.cast = mock.Mock()
self.endpoint = octavia_listener.NSXOctaviaListenerEndpoint(
client=self.clientMock,
loadbalancer=self.dummyResource,
listener=self.dummyResource,
pool=self.dummyResource,
member=self.dummyResource,
healthmonitor=self.dummyResource,
l7policy=self.dummyResource,
l7rule=self.dummyResource)
self.dummyObj = {'project_id': uuidutils.generate_uuid(),
'id': uuidutils.generate_uuid()}
self.ctx = None
self.mock_ctx = mock.patch("neutron_lib.context.Context")
self.mock_ctx.start()
def tearDown(self):
self.mock_ctx.stop()
super(TestNsxOctaviaListener, self).tearDown()
def test_loadbalancer_create(self):
self.dummyResource.create_called = False
self.endpoint.loadbalancer_create(self.ctx, self.dummyObj)
self.assertTrue(self.dummyResource.create_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'loadbalancers': [
{'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE',
'id': mock.ANY}]})
def test_loadbalancer_delete(self):
self.dummyResource.delete_called = False
self.endpoint.loadbalancer_delete(self.ctx, self.dummyObj)
self.assertTrue(self.dummyResource.delete_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'loadbalancers': [
{'operating_status': 'ONLINE',
'provisioning_status': 'DELETED',
'id': mock.ANY}]})
def test_loadbalancer_update(self):
self.dummyResource.update_called = False
self.endpoint.loadbalancer_update(self.ctx, self.dummyObj,
self.dummyObj)
self.assertTrue(self.dummyResource.update_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'loadbalancers': [
{'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE',
'id': mock.ANY}]})
def test_listener_create(self):
self.dummyResource.create_called = False
self.endpoint.listener_create(self.ctx, self.dummyObj, None)
self.assertTrue(self.dummyResource.create_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'listeners': [
{'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE',
'id': mock.ANY}]})
def test_listener_delete(self):
self.dummyResource.delete_called = False
self.endpoint.listener_delete(self.ctx, self.dummyObj)
self.assertTrue(self.dummyResource.delete_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'listeners': [
{'operating_status': 'ONLINE',
'provisioning_status': 'DELETED',
'id': mock.ANY}]})
def test_listener_update(self):
self.dummyResource.update_called = False
self.endpoint.listener_update(self.ctx, self.dummyObj, self.dummyObj,
None)
self.assertTrue(self.dummyResource.update_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'listeners': [
{'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE',
'id': mock.ANY}]})
def test_pool_create(self):
self.dummyResource.create_called = False
self.endpoint.pool_create(self.ctx, self.dummyObj)
self.assertTrue(self.dummyResource.create_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'pools': [
{'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE',
'id': mock.ANY}]})
def test_pool_delete(self):
self.dummyResource.delete_called = False
self.endpoint.pool_delete(self.ctx, self.dummyObj)
self.assertTrue(self.dummyResource.delete_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'pools': [
{'operating_status': 'ONLINE',
'provisioning_status': 'DELETED',
'id': mock.ANY}]})
def test_pool_update(self):
self.dummyResource.update_called = False
self.endpoint.pool_update(self.ctx, self.dummyObj, self.dummyObj)
self.assertTrue(self.dummyResource.update_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'pools': [
{'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE',
'id': mock.ANY}]})
def test_member_create(self):
self.dummyResource.create_called = False
self.endpoint.member_create(self.ctx, self.dummyObj)
self.assertTrue(self.dummyResource.create_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'members': [
{'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE',
'id': mock.ANY}]})
def test_member_delete(self):
self.dummyResource.delete_called = False
self.endpoint.member_delete(self.ctx, self.dummyObj)
self.assertTrue(self.dummyResource.delete_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'members': [
{'operating_status': 'ONLINE',
'provisioning_status': 'DELETED',
'id': mock.ANY}]})
def test_member_update(self):
self.dummyResource.update_called = False
self.endpoint.member_update(self.ctx, self.dummyObj, self.dummyObj)
self.assertTrue(self.dummyResource.update_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'members': [
{'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE',
'id': mock.ANY}]})
def test_healthmonitor_create(self):
self.dummyResource.create_called = False
self.endpoint.healthmonitor_create(self.ctx, self.dummyObj)
self.assertTrue(self.dummyResource.create_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'healthmonitors': [
{'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE',
'id': mock.ANY}]})
def test_healthmonitor_delete(self):
self.dummyResource.delete_called = False
self.endpoint.healthmonitor_delete(self.ctx, self.dummyObj)
self.assertTrue(self.dummyResource.delete_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'healthmonitors': [
{'operating_status': 'ONLINE',
'provisioning_status': 'DELETED',
'id': mock.ANY}]})
def test_healthmonitor_update(self):
self.dummyResource.update_called = False
self.endpoint.healthmonitor_update(self.ctx, self.dummyObj,
self.dummyObj)
self.assertTrue(self.dummyResource.update_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'healthmonitors': [
{'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE',
'id': mock.ANY}]})
def test_l7policy_create(self):
self.dummyResource.create_called = False
self.endpoint.l7policy_create(self.ctx, self.dummyObj)
self.assertTrue(self.dummyResource.create_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'l7policies': [
{'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE',
'id': mock.ANY}]})
def test_l7policy_delete(self):
self.dummyResource.delete_called = False
self.endpoint.l7policy_delete(self.ctx, self.dummyObj)
self.assertTrue(self.dummyResource.delete_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'l7policies': [
{'operating_status': 'ONLINE',
'provisioning_status': 'DELETED',
'id': mock.ANY}]})
def test_l7policy_update(self):
self.dummyResource.update_called = False
self.endpoint.l7policy_update(self.ctx, self.dummyObj, self.dummyObj)
self.assertTrue(self.dummyResource.update_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'l7policies': [
{'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE',
'id': mock.ANY}]})
def test_l7rule_create(self):
self.dummyResource.create_called = False
self.endpoint.l7rule_create(self.ctx, self.dummyObj)
self.assertTrue(self.dummyResource.create_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'l7rules': [
{'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE',
'id': mock.ANY}]})
def test_l7rule_delete(self):
self.dummyResource.delete_called = False
self.endpoint.l7rule_delete(self.ctx, self.dummyObj)
self.assertTrue(self.dummyResource.delete_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'l7rules': [
{'operating_status': 'ONLINE',
'provisioning_status': 'DELETED',
'id': mock.ANY}]})
def test_l7rule_update(self):
self.dummyResource.update_called = False
self.endpoint.l7rule_update(self.ctx, self.dummyObj, self.dummyObj)
self.assertTrue(self.dummyResource.update_called)
self.clientMock.cast.assert_called_once_with(
{}, 'update_loadbalancer_status',
status={'l7rules': [
{'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE',
'id': mock.ANY}]})

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

@ -44,8 +44,15 @@ class TestQosNsxVNotification(test_plugin.NsxVPluginV2TestCase,
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)
# Skip Octavia init because of RPC conflicts
with mock.patch("vmware_nsx.services.lbaas.octavia.octavia_listener."
"NSXOctaviaListener.__init__", return_value=None),\
mock.patch("vmware_nsx.services.lbaas.octavia.octavia_listener."
"NSXOctaviaStatisticsCollector.__init__",
return_value=None):
super(TestQosNsxVNotification, self).setUp(plugin=CORE_PLUGIN,
ext_mgr=None,
with_md_proxy=False)
self.setup_coreplugin(CORE_PLUGIN)
plugin_instance = directory.get_plugin()