1123990897
Ensure the floating IP status is put ACTIVE or DOWN when it is associated or disassociated. This is done directly on the plugin class as the NSX backend applies relevant NAT rules synchronously. Change-Id: Ie747c4eae2ac33016fdabaade2335f7d2d24eec9 Closes-Bug: #1334708
294 lines
13 KiB
Python
294 lines
13 KiB
Python
# Copyright (c) 2013 OpenStack Foundation.
|
|
#
|
|
# 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
|
|
|
|
from eventlet import greenthread
|
|
import mock
|
|
from oslo.config import cfg
|
|
|
|
from neutron.api.v2 import attributes
|
|
from neutron.common import constants
|
|
from neutron import context
|
|
from neutron.extensions import l3
|
|
from neutron import manager as n_manager
|
|
from neutron.openstack.common import uuidutils
|
|
from neutron.plugins.vmware.common import utils
|
|
from neutron.plugins.vmware.plugins import service as nsp
|
|
from neutron.tests import base
|
|
from neutron.tests.unit import test_l3_plugin
|
|
from neutron.tests.unit import vmware
|
|
from neutron.tests.unit.vmware import test_nsx_plugin
|
|
from neutron.tests.unit.vmware.vshield import fake_vcns
|
|
|
|
_uuid = uuidutils.generate_uuid
|
|
|
|
|
|
class ServiceRouterTestExtensionManager(object):
|
|
|
|
def get_resources(self):
|
|
# If l3 resources have been loaded and updated by main API
|
|
# router, update the map in the l3 extension so it will load
|
|
# the same attributes as the API router
|
|
l3_attr_map = copy.deepcopy(l3.RESOURCE_ATTRIBUTE_MAP)
|
|
for res in l3.RESOURCE_ATTRIBUTE_MAP.keys():
|
|
attr_info = attributes.RESOURCE_ATTRIBUTE_MAP.get(res)
|
|
if attr_info:
|
|
l3.RESOURCE_ATTRIBUTE_MAP[res] = attr_info
|
|
resources = l3.L3.get_resources()
|
|
# restore the original resources once the controllers are created
|
|
l3.RESOURCE_ATTRIBUTE_MAP = l3_attr_map
|
|
|
|
return resources
|
|
|
|
def get_actions(self):
|
|
return []
|
|
|
|
def get_request_extensions(self):
|
|
return []
|
|
|
|
|
|
class ServiceRouterTest(test_nsx_plugin.L3NatTest,
|
|
test_l3_plugin.L3NatTestCaseMixin):
|
|
|
|
def vcns_patch(self):
|
|
instance = self.mock_vcns.start()
|
|
self.vcns_instance = instance
|
|
instance.return_value.deploy_edge.side_effect = self.fc2.deploy_edge
|
|
instance.return_value.get_edge_id.side_effect = self.fc2.get_edge_id
|
|
instance.return_value.get_edge_deploy_status.side_effect = (
|
|
self.fc2.get_edge_deploy_status)
|
|
instance.return_value.delete_edge.side_effect = self.fc2.delete_edge
|
|
instance.return_value.update_interface.side_effect = (
|
|
self.fc2.update_interface)
|
|
instance.return_value.get_nat_config.side_effect = (
|
|
self.fc2.get_nat_config)
|
|
instance.return_value.update_nat_config.side_effect = (
|
|
self.fc2.update_nat_config)
|
|
instance.return_value.delete_nat_rule.side_effect = (
|
|
self.fc2.delete_nat_rule)
|
|
instance.return_value.get_edge_status.side_effect = (
|
|
self.fc2.get_edge_status)
|
|
instance.return_value.get_edges.side_effect = self.fc2.get_edges
|
|
instance.return_value.update_routes.side_effect = (
|
|
self.fc2.update_routes)
|
|
instance.return_value.create_lswitch.side_effect = (
|
|
self.fc2.create_lswitch)
|
|
instance.return_value.delete_lswitch.side_effect = (
|
|
self.fc2.delete_lswitch)
|
|
instance.return_value.get_loadbalancer_config.side_effect = (
|
|
self.fc2.get_loadbalancer_config)
|
|
instance.return_value.enable_service_loadbalancer.side_effect = (
|
|
self.fc2.enable_service_loadbalancer)
|
|
|
|
def setUp(self, ext_mgr=None, service_plugins=None):
|
|
cfg.CONF.set_override('api_extensions_path', vmware.NSXEXT_PATH)
|
|
cfg.CONF.set_override('task_status_check_interval', 200, group="vcns")
|
|
|
|
# vcns does not support duplicated router name, ignore router name
|
|
# validation for unit-test cases
|
|
self.fc2 = fake_vcns.FakeVcns(unique_router_name=False)
|
|
self.mock_vcns = mock.patch(vmware.VCNS_NAME, autospec=True)
|
|
self.vcns_patch()
|
|
mock_proxy = mock.patch(
|
|
"%s.%s" % (vmware.SERVICE_PLUGIN_NAME,
|
|
'_set_create_lswitch_proxy'))
|
|
mock_proxy.start()
|
|
|
|
ext_mgr = ext_mgr or ServiceRouterTestExtensionManager()
|
|
super(ServiceRouterTest, self).setUp(
|
|
plugin=vmware.SERVICE_PLUGIN_NAME,
|
|
service_plugins=service_plugins,
|
|
ext_mgr=ext_mgr)
|
|
|
|
self.fc2.set_fake_nsx_api(self.fc)
|
|
self.addCleanup(self.fc2.reset_all)
|
|
|
|
def tearDown(self):
|
|
plugin = n_manager.NeutronManager.get_plugin()
|
|
manager = plugin.vcns_driver.task_manager
|
|
# wait max ~10 seconds for all tasks to be finished
|
|
for i in range(100):
|
|
if not manager.has_pending_task():
|
|
break
|
|
greenthread.sleep(0.1)
|
|
if manager.has_pending_task():
|
|
manager.show_pending_tasks()
|
|
raise Exception(_("Tasks not completed"))
|
|
manager.stop()
|
|
# Ensure the manager thread has been stopped
|
|
self.assertIsNone(manager._thread)
|
|
super(ServiceRouterTest, self).tearDown()
|
|
|
|
def _create_router(self, fmt, tenant_id, name=None,
|
|
admin_state_up=None, set_context=False,
|
|
arg_list=None, **kwargs):
|
|
data = {'router': {'tenant_id': tenant_id}}
|
|
if name:
|
|
data['router']['name'] = name
|
|
if admin_state_up:
|
|
data['router']['admin_state_up'] = admin_state_up
|
|
for arg in (('admin_state_up', 'tenant_id') + (arg_list or ())):
|
|
# Arg must be present and not empty
|
|
if arg in kwargs and kwargs[arg]:
|
|
data['router'][arg] = kwargs[arg]
|
|
data['router']['service_router'] = True
|
|
router_req = self.new_create_request('routers', data, fmt)
|
|
if set_context and tenant_id:
|
|
# create a specific auth context for this request
|
|
router_req.environ['neutron.context'] = context.Context(
|
|
'', tenant_id)
|
|
|
|
return router_req.get_response(self.ext_api)
|
|
|
|
|
|
class ServiceRouterTestCase(ServiceRouterTest,
|
|
test_nsx_plugin.TestL3NatTestCase):
|
|
|
|
def test_router_create(self):
|
|
name = 'router1'
|
|
tenant_id = _uuid()
|
|
expected_value = [('name', name), ('tenant_id', tenant_id),
|
|
('admin_state_up', True),
|
|
('external_gateway_info', None),
|
|
('service_router', True)]
|
|
with self.router(name=name, admin_state_up=True,
|
|
tenant_id=tenant_id) as router:
|
|
expected_value_1 = expected_value + [('status', 'PENDING_CREATE')]
|
|
for k, v in expected_value_1:
|
|
self.assertEqual(router['router'][k], v)
|
|
|
|
# wait max ~10 seconds for router status update
|
|
for i in range(20):
|
|
greenthread.sleep(0.5)
|
|
res = self._show('routers', router['router']['id'])
|
|
if res['router']['status'] == 'ACTIVE':
|
|
break
|
|
expected_value_2 = expected_value + [('status', 'ACTIVE')]
|
|
for k, v in expected_value_2:
|
|
self.assertEqual(res['router'][k], v)
|
|
|
|
# check an integration lswitch is created
|
|
lswitch_name = "%s-ls" % name
|
|
for lswitch_id, lswitch in self.fc2._lswitches.iteritems():
|
|
if lswitch['display_name'] == lswitch_name:
|
|
break
|
|
else:
|
|
self.fail("Integration lswitch not found")
|
|
|
|
# check an integration lswitch is deleted
|
|
lswitch_name = "%s-ls" % name
|
|
for lswitch_id, lswitch in self.fc2._lswitches.iteritems():
|
|
if lswitch['display_name'] == lswitch_name:
|
|
self.fail("Integration switch is not deleted")
|
|
|
|
def test_router_delete_after_plugin_restart(self):
|
|
name = 'router1'
|
|
tenant_id = _uuid()
|
|
with self.router(name=name, admin_state_up=True,
|
|
tenant_id=tenant_id):
|
|
# clear router type cache to mimic plugin restart
|
|
plugin = n_manager.NeutronManager.get_plugin()
|
|
plugin._router_type = {}
|
|
|
|
# check an integration lswitch is deleted
|
|
lswitch_name = "%s-ls" % name
|
|
for lswitch_id, lswitch in self.fc2._lswitches.iteritems():
|
|
if lswitch['display_name'] == lswitch_name:
|
|
self.fail("Integration switch is not deleted")
|
|
|
|
def test_router_show(self):
|
|
name = 'router1'
|
|
tenant_id = _uuid()
|
|
expected_value = [('name', name), ('tenant_id', tenant_id),
|
|
('admin_state_up', True),
|
|
('status', 'PENDING_CREATE'),
|
|
('external_gateway_info', None),
|
|
('service_router', True)]
|
|
with self.router(name='router1', admin_state_up=True,
|
|
tenant_id=tenant_id) as router:
|
|
res = self._show('routers', router['router']['id'])
|
|
for k, v in expected_value:
|
|
self.assertEqual(res['router'][k], v)
|
|
|
|
def _test_router_create_with_gwinfo_and_l3_ext_net(self, vlan_id=None):
|
|
super(ServiceRouterTestCase,
|
|
self)._test_router_create_with_gwinfo_and_l3_ext_net(
|
|
vlan_id, validate_ext_gw=False)
|
|
|
|
def _test_router_update_gateway_on_l3_ext_net(self, vlan_id=None):
|
|
super(ServiceRouterTestCase,
|
|
self)._test_router_update_gateway_on_l3_ext_net(
|
|
vlan_id, validate_ext_gw=False)
|
|
|
|
def test_floatingip_update(self):
|
|
self._test_floatingip_update(constants.FLOATINGIP_STATUS_ACTIVE)
|
|
|
|
|
|
class TestProxyCreateLswitch(base.BaseTestCase):
|
|
def setUp(self):
|
|
super(TestProxyCreateLswitch, self).setUp()
|
|
self.tenant_id = "foo_tenant"
|
|
self.display_name = "foo_network"
|
|
self.tz_config = [
|
|
{'zone_uuid': 'foo_zone',
|
|
'transport_type': 'stt'}
|
|
]
|
|
self.tags = utils.get_tags(quantum_net_id='foo_id',
|
|
os_tid=self.tenant_id)
|
|
self.cluster = None
|
|
|
|
def test_create_lswitch_with_basic_args(self):
|
|
result = nsp._process_base_create_lswitch_args(self.cluster,
|
|
'foo_id',
|
|
self.tenant_id,
|
|
self.display_name,
|
|
self.tz_config)
|
|
self.assertEqual(self.display_name, result[0])
|
|
self.assertEqual(self.tz_config, result[1])
|
|
self.assertEqual(sorted(self.tags), sorted(result[2]))
|
|
|
|
def test_create_lswitch_with_shared_as_kwarg(self):
|
|
result = nsp._process_base_create_lswitch_args(self.cluster,
|
|
'foo_id',
|
|
self.tenant_id,
|
|
self.display_name,
|
|
self.tz_config,
|
|
shared=True)
|
|
expected = self.tags + [{'scope': 'shared', 'tag': 'true'}]
|
|
self.assertEqual(sorted(expected), sorted(result[2]))
|
|
|
|
def test_create_lswitch_with_shared_as_arg(self):
|
|
result = nsp._process_base_create_lswitch_args(self.cluster,
|
|
'foo_id',
|
|
self.tenant_id,
|
|
self.display_name,
|
|
self.tz_config,
|
|
True)
|
|
additional_tags = [{'scope': 'shared', 'tag': 'true'}]
|
|
expected = self.tags + additional_tags
|
|
self.assertEqual(sorted(expected), sorted(result[2]))
|
|
|
|
def test_create_lswitch_with_additional_tags(self):
|
|
more_tags = [{'scope': 'foo_scope', 'tag': 'foo_tag'}]
|
|
result = nsp._process_base_create_lswitch_args(self.cluster,
|
|
'foo_id',
|
|
self.tenant_id,
|
|
self.display_name,
|
|
self.tz_config,
|
|
tags=more_tags)
|
|
expected = self.tags + more_tags
|
|
self.assertEqual(sorted(expected), sorted(result[2]))
|