307 lines
12 KiB
Python
307 lines
12 KiB
Python
# Copyright (c) 2012 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 mock
|
|
|
|
from oslo.config import cfg
|
|
|
|
from neutron.db import api as db
|
|
from neutron.extensions import providernet as provider
|
|
from neutron.openstack.common import importutils
|
|
from neutron.plugins.cisco.common import cisco_constants as const
|
|
from neutron.plugins.cisco.common import cisco_exceptions as cisco_exc
|
|
from neutron.plugins.cisco.db import network_db_v2 as cdb
|
|
from neutron.plugins.cisco.nexus import cisco_nexus_plugin_v2
|
|
from neutron.tests import base
|
|
|
|
|
|
NEXUS_IP_ADDRESS = '1.1.1.1'
|
|
HOSTNAME1 = 'testhost1'
|
|
HOSTNAME2 = 'testhost2'
|
|
HOSTNAME3 = 'testhost3'
|
|
INSTANCE1 = 'testvm1'
|
|
INSTANCE2 = 'testvm2'
|
|
INSTANCE3 = 'testvm3'
|
|
NEXUS_PORT1 = '1/10'
|
|
NEXUS_PORT2 = '1/20'
|
|
NEXUS_PC_IP_ADDRESS = '2.2.2.2'
|
|
NEXUS_PORTCHANNELS = 'portchannel:2'
|
|
PC_HOSTNAME = 'testpchost'
|
|
NEXUS_SSH_PORT = '22'
|
|
NEXUS_DRIVER = ('neutron.plugins.cisco.nexus.'
|
|
'cisco_nexus_network_driver_v2.CiscoNEXUSDriver')
|
|
NET_ATTRS = [const.NET_ID,
|
|
const.NET_NAME,
|
|
const.NET_VLAN_NAME,
|
|
const.NET_VLAN_ID]
|
|
|
|
|
|
class TestCiscoNexusPlugin(base.BaseTestCase):
|
|
|
|
def setUp(self):
|
|
"""Set up function."""
|
|
super(TestCiscoNexusPlugin, self).setUp()
|
|
self.tenant_id = "test_tenant_cisco1"
|
|
self.net_name = "test_network_cisco1"
|
|
self.net_id = 7
|
|
self.vlan_name = "q-" + str(self.net_id) + "vlan"
|
|
self.vlan_id = 267
|
|
self.second_tenant_id = "test_tenant_2"
|
|
self.second_net_name = "test_network_cisco2"
|
|
self.second_net_id = 5
|
|
self.second_vlan_name = "q-" + str(self.second_net_id) + "vlan"
|
|
self.second_vlan_id = 265
|
|
self._pchostname = PC_HOSTNAME
|
|
|
|
self.attachment1 = {
|
|
const.TENANT_ID: self.tenant_id,
|
|
const.INSTANCE_ID: INSTANCE1,
|
|
const.HOST_NAME: HOSTNAME1,
|
|
}
|
|
self.attachment2 = {
|
|
const.TENANT_ID: self.second_tenant_id,
|
|
const.INSTANCE_ID: INSTANCE2,
|
|
const.HOST_NAME: HOSTNAME2,
|
|
}
|
|
self.attachment3 = {
|
|
const.TENANT_ID: self.second_tenant_id,
|
|
const.INSTANCE_ID: INSTANCE3,
|
|
const.HOST_NAME: HOSTNAME3,
|
|
}
|
|
self.network1 = {
|
|
const.NET_ID: self.net_id,
|
|
const.NET_NAME: self.net_name,
|
|
const.NET_VLAN_NAME: self.vlan_name,
|
|
const.NET_VLAN_ID: self.vlan_id,
|
|
}
|
|
self.network2 = {
|
|
const.NET_ID: self.second_net_id,
|
|
const.NET_NAME: self.second_net_name,
|
|
const.NET_VLAN_NAME: self.second_vlan_name,
|
|
const.NET_VLAN_ID: self.second_vlan_id,
|
|
}
|
|
self.network3 = {
|
|
const.NET_ID: 8,
|
|
const.NET_NAME: 'vpc_net',
|
|
const.NET_VLAN_NAME: 'q-268',
|
|
const.NET_VLAN_ID: '268',
|
|
}
|
|
self.providernet = {
|
|
const.NET_ID: 9,
|
|
const.NET_NAME: 'pnet1',
|
|
const.NET_VLAN_NAME: 'p-300',
|
|
const.NET_VLAN_ID: 300,
|
|
provider.NETWORK_TYPE: 'vlan',
|
|
provider.PHYSICAL_NETWORK: self.net_name + '200:299',
|
|
provider.SEGMENTATION_ID: 300,
|
|
}
|
|
|
|
def new_nexus_init(self):
|
|
self._client = importutils.import_object(NEXUS_DRIVER)
|
|
self._client.nexus_switches = {
|
|
(NEXUS_IP_ADDRESS, HOSTNAME1): NEXUS_PORT1,
|
|
(NEXUS_IP_ADDRESS, 'ssh_port'): NEXUS_SSH_PORT,
|
|
(NEXUS_IP_ADDRESS, HOSTNAME2): NEXUS_PORT2,
|
|
(NEXUS_IP_ADDRESS, 'ssh_port'): NEXUS_SSH_PORT,
|
|
(NEXUS_PC_IP_ADDRESS, 'ssh_port'): NEXUS_SSH_PORT,
|
|
}
|
|
self._nexus_switches = {
|
|
('NEXUS_SWITCH', NEXUS_IP_ADDRESS, HOSTNAME1): NEXUS_PORT1,
|
|
('NEXUS_SWITCH', NEXUS_IP_ADDRESS, HOSTNAME2): NEXUS_PORT2,
|
|
('NEXUS_SWITCH', NEXUS_PC_IP_ADDRESS, HOSTNAME3):
|
|
NEXUS_PORTCHANNELS,
|
|
('NEXUS_SWITCH', NEXUS_PC_IP_ADDRESS, 'ssh_port'):
|
|
NEXUS_SSH_PORT,
|
|
('NEXUS_SWITCH', NEXUS_IP_ADDRESS, HOSTNAME3):
|
|
NEXUS_PORTCHANNELS,
|
|
('NEXUS_SWITCH', NEXUS_IP_ADDRESS, 'ssh_port'): NEXUS_SSH_PORT,
|
|
}
|
|
self._client.credentials = {
|
|
NEXUS_IP_ADDRESS: {
|
|
'username': 'admin',
|
|
'password': 'pass1234'
|
|
},
|
|
NEXUS_PC_IP_ADDRESS: {
|
|
'username': 'admin',
|
|
'password': 'password'
|
|
},
|
|
}
|
|
db.configure_db()
|
|
|
|
self.addCleanup(db.clear_db)
|
|
# Use a mock netconf client
|
|
self.mock_ncclient = mock.Mock()
|
|
self.patch_obj = mock.patch.dict('sys.modules',
|
|
{'ncclient': self.mock_ncclient})
|
|
self.patch_obj.start()
|
|
|
|
with mock.patch.object(cisco_nexus_plugin_v2.NexusPlugin,
|
|
'__init__', new=new_nexus_init):
|
|
self._cisco_nexus_plugin = cisco_nexus_plugin_v2.NexusPlugin()
|
|
|
|
self.addCleanup(self.patch_obj.stop)
|
|
|
|
def test_create_delete_networks(self):
|
|
"""Tests creation of two new Virtual Networks."""
|
|
new_net_dict = self._cisco_nexus_plugin.create_network(
|
|
self.network1, self.attachment1)
|
|
for attr in NET_ATTRS:
|
|
self.assertEqual(new_net_dict[attr], self.network1[attr])
|
|
|
|
expected_instance_id = self._cisco_nexus_plugin.delete_port(
|
|
INSTANCE1, self.vlan_id)
|
|
|
|
self.assertEqual(expected_instance_id, INSTANCE1)
|
|
|
|
new_net_dict = self._cisco_nexus_plugin.create_network(
|
|
self.network2, self.attachment1)
|
|
for attr in NET_ATTRS:
|
|
self.assertEqual(new_net_dict[attr], self.network2[attr])
|
|
|
|
expected_instance_id = self._cisco_nexus_plugin.delete_port(
|
|
INSTANCE1, self.second_vlan_id)
|
|
|
|
self.assertEqual(expected_instance_id, INSTANCE1)
|
|
|
|
def test_create_providernet(self):
|
|
with mock.patch.object(cdb, 'is_provider_vlan',
|
|
return_value=True) as mock_db:
|
|
new_net_dict = self._cisco_nexus_plugin.create_network(
|
|
self.providernet, self.attachment1)
|
|
mock_db.assert_called_once()
|
|
for attr in NET_ATTRS:
|
|
self.assertEqual(new_net_dict[attr], self.providernet[attr])
|
|
|
|
def test_create_provider_vlan_network_cfg_auto_man(self):
|
|
cfg.CONF.set_override('provider_vlan_auto_create', True, 'CISCO')
|
|
cfg.CONF.set_override('provider_vlan_auto_trunk', False, 'CISCO')
|
|
self.addCleanup(cfg.CONF.reset)
|
|
with mock.patch.object(cdb, 'is_provider_vlan', return_value=True):
|
|
new_net_dict = self._cisco_nexus_plugin.create_network(
|
|
self.providernet, self.attachment1)
|
|
for attr in NET_ATTRS:
|
|
self.assertEqual(new_net_dict[attr], self.providernet[attr])
|
|
|
|
def test_create_provider_vlan_network_cfg_man_auto(self):
|
|
cfg.CONF.set_override('provider_vlan_auto_create', False, 'CISCO')
|
|
cfg.CONF.set_override('provider_vlan_auto_trunk', True, 'CISCO')
|
|
self.addCleanup(cfg.CONF.reset)
|
|
with mock.patch.object(cdb, 'is_provider_vlan', return_value=True):
|
|
new_net_dict = self._cisco_nexus_plugin.create_network(
|
|
self.providernet, self.attachment1)
|
|
for attr in NET_ATTRS:
|
|
self.assertEqual(new_net_dict[attr], self.providernet[attr])
|
|
|
|
def test_create_provider_vlan_network_cfg_man_man(self):
|
|
cfg.CONF.set_override('provider_vlan_auto_create', False, 'CISCO')
|
|
cfg.CONF.set_override('provider_vlan_auto_trunk', False, 'CISCO')
|
|
self.addCleanup(cfg.CONF.reset)
|
|
with mock.patch.object(cdb, 'is_provider_vlan', return_value=True):
|
|
new_net_dict = self._cisco_nexus_plugin.create_network(
|
|
self.providernet, self.attachment1)
|
|
for attr in NET_ATTRS:
|
|
self.assertEqual(new_net_dict[attr], self.providernet[attr])
|
|
|
|
def test_create_delete_network_portchannel(self):
|
|
"""Tests creation of a network over a portchannel."""
|
|
new_net_dict = self._cisco_nexus_plugin.create_network(
|
|
self.network3, self.attachment3)
|
|
self.assertEqual(new_net_dict[const.NET_ID],
|
|
self.network3[const.NET_ID])
|
|
self.assertEqual(new_net_dict[const.NET_NAME],
|
|
self.network3[const.NET_NAME])
|
|
self.assertEqual(new_net_dict[const.NET_VLAN_NAME],
|
|
self.network3[const.NET_VLAN_NAME])
|
|
self.assertEqual(new_net_dict[const.NET_VLAN_ID],
|
|
self.network3[const.NET_VLAN_ID])
|
|
|
|
self._cisco_nexus_plugin.delete_port(
|
|
INSTANCE3, self.network3[const.NET_VLAN_ID]
|
|
)
|
|
|
|
def test_nexus_add_remove_router_interface(self):
|
|
"""Tests addition of a router interface."""
|
|
vlan_name = self.vlan_name
|
|
vlan_id = self.vlan_id
|
|
gateway_ip = '10.0.0.1/24'
|
|
router_id = '00000R1'
|
|
subnet_id = '00001'
|
|
|
|
result = self._cisco_nexus_plugin.add_router_interface(vlan_name,
|
|
vlan_id,
|
|
subnet_id,
|
|
gateway_ip,
|
|
router_id)
|
|
self.assertTrue(result)
|
|
result = self._cisco_nexus_plugin.remove_router_interface(vlan_id,
|
|
router_id)
|
|
self.assertEqual(result, router_id)
|
|
|
|
def test_nexus_add_router_interface_fail(self):
|
|
"""Tests deletion of a router interface."""
|
|
vlan_name = self.vlan_name
|
|
vlan_id = self.vlan_id
|
|
gateway_ip = '10.0.0.1/24'
|
|
router_id = '00000R1'
|
|
subnet_id = '00001'
|
|
|
|
self._cisco_nexus_plugin.add_router_interface(vlan_name,
|
|
vlan_id,
|
|
subnet_id,
|
|
gateway_ip,
|
|
router_id)
|
|
try:
|
|
self.assertRaises(
|
|
cisco_exc.SubnetInterfacePresent,
|
|
self._cisco_nexus_plugin.add_router_interface,
|
|
vlan_name, vlan_id, subnet_id, gateway_ip, router_id)
|
|
finally:
|
|
self._cisco_nexus_plugin.remove_router_interface(vlan_id,
|
|
router_id)
|
|
|
|
def test_nexus_add_port_after_router_interface(self):
|
|
"""Tests creating a port after a router interface.
|
|
|
|
Test creating a port after an SVI router interface has
|
|
been created. Only a trunk call should be invoked and the
|
|
plugin should not attempt to recreate the vlan.
|
|
"""
|
|
vlan_name = self.vlan_name
|
|
vlan_id = self.vlan_id
|
|
gateway_ip = '10.0.0.1/24'
|
|
router_id = '00000R1'
|
|
subnet_id = '00001'
|
|
|
|
self._cisco_nexus_plugin.add_router_interface(vlan_name,
|
|
vlan_id,
|
|
subnet_id,
|
|
gateway_ip,
|
|
router_id)
|
|
# Create a network on the switch
|
|
self._cisco_nexus_plugin.create_network(
|
|
self.network1, self.attachment1)
|
|
|
|
# Grab a list of all mock calls from ncclient
|
|
last_cfgs = (self.mock_ncclient.manager.connect().
|
|
edit_config.mock_calls)
|
|
|
|
# The last ncclient call should be for trunking and the second
|
|
# to last call should be creating the SVI interface
|
|
last_cfg = last_cfgs[-1][2]['config']
|
|
self.assertIn('allowed', last_cfg)
|
|
|
|
slast_cfg = last_cfgs[-2][2]['config']
|
|
self.assertIn('10.0.0.1/24', slast_cfg)
|