def _create_subnet(self, network, cidr):
user_enterprise = self.session.user.enterprises.get_first(
filter='name == "{}"'.format(utils.get_vsd_net_parition_name()))
# Create VSD managed subnet
l3domain = utils.create_l3_domain(self, user_enterprise)
zone = l3domain.create_child(
vspk.NUZone(name=utils.get_random_name()))[0]
subnet = zone.create_child(
vspk.NUSubnet(name=utils.get_random_name(),
address=str(cidr.ip),
netmask=str(cidr.netmask)))[0]
cmd_create = ('subnet create -f json --network {network} '
'--net-partition {net_partition} --nuagenet {nuagenet} '
'--subnet-range {subnet_range} {subnet_name}'
.format(network=network,
net_partition=user_enterprise.id,
nuagenet=subnet.id,
subnet_range=cidr,
subnet_name=utils.get_random_name()))
create_output = json.loads(self.openstack(cmd_create))
self.addCleanup(self.openstack,
'subnet delete {}'.format(create_output['id']))
return create_output, l3domain
def setUp(self):
super(NuagePolicyGroupTests, self).setUp()
network = self._create_network()
self.subnet1, self.l3domain1 = self._create_subnet(
network=network['id'],
cidr=netaddr.IPNetwork('10.0.0.0/24'))
self.subnet2, self.l3domain2 = self._create_subnet(
network=network['id'],
cidr=netaddr.IPNetwork('20.0.0.0/24'))
self.nuage_pg1 = self._create_nuage_pg(
self.l3domain1,
name=utils.get_random_name(),
type='SOFTWARE',
description=utils.get_random_name(),
evpn_community_tag='1:2',
external=True)
self.nuage_pg2 = self._create_nuage_pg(
self.l3domain2,
name=utils.get_random_name(),
type='SOFTWARE',
description=utils.get_random_name(),
external=False)
self.port1 = self._create_port(network_id=network['id'],
subnet_id=self.subnet1['id'])
self.port2 = self._create_port(network_id=network['id'],
subnet_id=self.subnet2['id'])
def test_nuage_uplink_option(self):
external_network_1_name = get_random_name()
self.openstack('network create --external {}'
.format(external_network_1_name))
self.addCleanup(self.openstack, 'network delete {}'
.format(external_network_1_name))
external_network_2_name = get_random_name()
self.openstack('network create --external {}'
.format(external_network_2_name))
self.addCleanup(self.openstack, 'network delete {}'
.format(external_network_2_name))
subnet_1_name = get_random_name()
cmd = ('subnet create -f json --underlay False --network {network} '
'--subnet-range'.format(network=external_network_1_name))
cmd_output = self._subnet_create(cmd, subnet_1_name)
self.addCleanup(self.openstack, ('subnet delete {}'
.format(subnet_1_name)))
nuage_uplink_1 = cmd_output['nuage_uplink']
self.assertIsNotNone(nuage_uplink_1)
subnet_2_name = get_random_name()
cmd = ('subnet create -f json --underlay False --network {network} '
'--nuage-uplink {uplink} '
'--subnet-range'.format(network=external_network_2_name,
uplink=nuage_uplink_1))
cmd_output = self._subnet_create(cmd, subnet_2_name)
self.addCleanup(self.openstack, ('subnet delete {}'
.format(subnet_2_name)))
nuage_uplink_2 = cmd_output['nuage_uplink']
self.assertEqual(nuage_uplink_1, nuage_uplink_2)
def setUp(self):
super(NuagePortTestsVSDManaged, self).setUp()
# Create VSD managed subnet
user_enterprise = self.session.user.enterprises.get_first(
filter='name == "{}"'.format(utils.get_vsd_net_parition_name()))
self.l3domain = utils.create_l3_domain(self, user_enterprise)
zone = self.l3domain.create_child(
vspk.NUZone(name=utils.get_random_name()))[0]
subnet = zone.create_child(
vspk.NUSubnet(name=utils.get_random_name(),
address='10.0.0.0',
netmask='255.255.255.0'))[0]
cmd_create = ('subnet create -f json --network {network} '
'--net-partition {net_partition} --nuagenet {nuagenet} '
'--subnet-range {subnet_range} {subnet_name}'.format(
network=self.NETWORK_NAME,
net_partition=user_enterprise.id,
nuagenet=subnet.id,
subnet_range='10.0.0.0/24',
subnet_name=utils.get_random_name()))
create_output = json.loads(self.openstack(cmd_create))
self.addCleanup(self.openstack,
'subnet delete {}'.format(create_output['id']))
def test_nuage_underlay_option(self):
router_name = get_random_name()
self.openstack('router create {}'.format(router_name))
self.addCleanup(self.openstack, 'router delete {}'.format(router_name))
subnet_name = get_random_name()
self._subnet_create('subnet create -f json'
' --network {network} --subnet-range'
.format(network=self.NETWORK_NAME), subnet_name)
self.addCleanup(self.openstack, 'subnet delete {}'.format(subnet_name))
self.openstack('router add subnet {router} {subnet}'
.format(router=router_name, subnet=subnet_name))
self.addCleanup(self.openstack,
'router remove subnet {router} {subnet}'
.format(router=router_name, subnet=subnet_name))
for (param, expected) in [('', 'inherited'), ('off', 'off'),
('route', 'route'), ('snat', 'snat')]:
if param:
param = '--nuage-underlay ' + param
self.openstack('subnet set {param} {subnet}'
.format(param=param, subnet=subnet_name))
cmd_output = json.loads(self.openstack("subnet show -f json {}"
.format(subnet_name)))
self.assertEqual(expected=expected,
observed=cmd_output['nuage_underlay'])
def test_underlay_option(self):
router_name = get_random_name()
self.openstack('router create {}'.format(router_name))
self.addCleanup(self.openstack, 'router delete {}'.format(router_name))
external_network_name = get_random_name()
self.openstack('network create --external {}'
.format(external_network_name))
self.addCleanup(self.openstack, 'network delete {}'
.format(external_network_name))
for is_underlay_enabled in [True, False]:
subnet_name = get_random_name()
underlay_argument = ('--underlay True' if is_underlay_enabled
else '--underlay False')
cmd = ('subnet create -f json {underlay} --network {network} '
'--subnet-range'.format(underlay=underlay_argument,
network=external_network_name))
cmd_output = self._subnet_create(cmd, subnet_name)
self.assertEqual(expected=is_underlay_enabled,
observed=cmd_output['underlay'])
self.assertEqual(expected=False,
observed=cmd_output['vsd_managed'])
self.openstack('subnet delete {}'.format(subnet_name))
def setUp(self):
super(NuageRedirectTargetTests, self).setUp()
network = self._create_network()
self.subnetl3, self.l3domain = self._create_topology(
network=network['id'], cidr=netaddr.IPNetwork('10.0.0.0/24'))
self.subnetl2, self.l2domain = self._create_topology(
network=network['id'],
cidr=netaddr.IPNetwork('20.0.0.0/24'),
is_l3=False)
self.nuage_rtl3 = self._create_nuage_rt(
self.l3domain,
name=utils.get_random_name(),
end_point_type='L3',
description=utils.get_random_name())
self.nuage_rtl2 = self._create_nuage_rt(
self.l2domain,
name=utils.get_random_name(),
end_point_type='VIRTUAL_WIRE',
description=utils.get_random_name())
self.portl3 = self._create_port(network_id=network['id'],
subnet_id=self.subnetl3['id'])
self.portl2 = self._create_port(network_id=network['id'],
subnet_id=self.subnetl2['id'])
def test_nuage_redirect_target_option(self):
# Note that this test only checks one redirect target per port
# as it is unclear how to add multiple redirect targets at the moment
# create RedirectionTarget instances on VSD
rt_names = [utils.get_random_name() for _ in range(2)]
rt_ids = [
self.l3domain.create_child(
vspk.NURedirectionTarget(name=rt_name,
endPointType='L3'))[0].id
for rt_name in rt_names
]
# create port with the redirect target in the VSD managed subnet
# and verify
port_name = utils.get_random_name()
rts_arg = '--nuage-redirect-target {}'.format(rt_names[0])
cmd_create = ('port create -f json {rts_arg} '
'--network {network} {name}'.format(
rts_arg=rts_arg,
network=self.NETWORK_NAME,
name=port_name))
cmd_output = json.loads(self.openstack(cmd_create))
self.assertEqual(observed=cmd_output['nuage_redirect_targets'],
expected=rt_ids[0])
# Set rt that is already set (nothing should change)
cmd_set = 'port set --nuage-redirect-target {rt_name} {port}'.format(
rt_name=rt_names[0], port=port_name)
cmd_output = self.openstack(cmd_set)
self.assertEqual(expected='', observed=cmd_output)
cmd_output = self._port_show(port_name)
self.assertEqual(expected=rt_ids[0],
observed=cmd_output['nuage_redirect_targets'])
# Unset and verify
cmd_no_rts = ('port unset --nuage-redirect-target {port}'.format(
port=port_name))
cmd_output = self.openstack(cmd_no_rts)
self.assertEqual(expected='', observed=cmd_output)
cmd_output = self._port_show(port_name)
self.assertIsNone(cmd_output['nuage_redirect_targets'])
# Overwrite and verify
cmd_set = ('port set --nuage-redirect-target {} {}'.format(
rt_ids[1], port_name))
cmd_output = self.openstack(cmd_set)
self.assertEqual(expected='', observed=cmd_output)
cmd_output = self._port_show(port_name)
self.assertEqual(expected=rt_ids[1],
observed=cmd_output['nuage_redirect_targets'])
# delete and verify
utils.delete_and_verify(self, 'port', port_name)
def test_basic_create_list_show(self):
netpartition1_name = get_random_name()
self.create_and_verify(netpartition1_name, clean_up=False)
self.list_and_verify(netpartition1_name)
self.show_and_verify(netpartition1_name)
delete_and_verify(self, 'nuage netpartition', netpartition1_name)
def test_create_list_show_delete_id(self):
netpartition1_name = get_random_name()
np, project = self._create_and_verify(netpartition1_name)
self._list_and_verify(np, project)
self._show_and_verify(np, project)
self._delete_and_verify(project['id'])
def setUpClass(cls):
super(NuageFloatingIPExtensionTests, cls).setUpClass()
cls.random_name = utils.get_random_name()
# Private network
cls.openstack('network create {}'.format(cls.random_name))
cls.openstack(('subnet create --subnet-range 99.168.0.1/24 '
'--network {} {}'.format(cls.random_name,
cls.random_name)))
cls.openstack('port create --network {} {}'.format(
cls.random_name, cls.random_name))
# Public network
cls.openstack('network create --external public-{}'.format(
cls.random_name))
cls.openstack(
(('subnet create --subnet-range 98.0.2.1/24 '
'--network public-{} public-{}'.format(cls.random_name,
cls.random_name))))
# Router
cls.openstack('router create {}'.format(cls.random_name))
cls.openstack(('router set --external-gateway {} {}'.format(
'public-{}'.format(cls.random_name), cls.random_name)))
cls.openstack(
('router add subnet {} {}'.format(cls.random_name,
cls.random_name)))
def test_stateful_option(self):
# test create with no option
sg = self._create(name=utils.get_random_name())
self.assertIn(needle='stateful', haystack=sg)
self.assertIn(needle=sg['stateful'], haystack=[True, False])
# test create with --stateful
sg1 = self._create(name=utils.get_random_name(),
extra_params='--stateful')
self.assertIn(needle='stateful', haystack=sg1)
self.assertEqual(expected=True, observed=sg1['stateful'])
# test create with --no-stateful
sg2 = self._create(name=utils.get_random_name(),
extra_params='--no-stateful')
self.assertIn(needle='stateful', haystack=sg2)
self.assertEqual(expected=False, observed=sg2['stateful'])
# test create with illegal option combination
self.assertRaisesRegex(
tempest_exceptions.CommandFailed,
'error: argument --stateful: not allowed with argument '
'--no-stateful',
self._create,
name=utils.get_random_name(),
extra_params='--no-stateful --stateful')
# test show
for sg in [sg1, sg2]:
output = self._show(sg['id'])
self.assertIn(needle='stateful', haystack=output)
self.assertEqual(expected=sg['stateful'],
observed=output['stateful'])
# test set (invert stateful value)
for sg in [sg1, sg2]:
param = '--no-stateful' if sg['stateful'] else '--stateful'
output = self._set(sg['id'], param)
self.assertEqual(expected='', observed=output)
# test show inverted values after set
for sg in [sg1, sg2]:
output = self._show(sg['id'])
self.assertIn(needle='stateful', haystack=output)
self.assertEqual(expected=not sg['stateful'],
observed=output['stateful'])
def _create_port(self, network_id, subnet_id):
port_name = utils.get_random_name()
cmd_create = ('port create -f json --network {network}'
' --fixed-ip subnet={subnet} {name}'.format(
network=network_id, subnet=subnet_id,
name=port_name))
self.addCleanup(self.openstack, 'port delete {}'.format(port_name))
return json.loads(self.openstack(cmd_create))
def _create_l3_domain_template(self):
template = self.enterprise.create_child(
vspk.NUDomainTemplate(name=utils.get_random_name()))[0]
template.create_child(vspk.NUZoneTemplate(name='openstack-isolated'))
template.create_child(vspk.NUZoneTemplate(name='openstack-shared'))
self.addCleanup(template.delete)
return template
def _create_shared_fip_subnet(self, session, address, netmask):
shared_enterprise = session.user.enterprises.get_first(
filter='name == "Shared Infrastructure"')
l3_domain_template_shared_infra = \
shared_enterprise.domain_templates.get_first(
filter='name == "Shared Domain template"')
shared_l3_domain = shared_enterprise.create_child(
vspk.NUDomain(name=utils.get_random_name(),
template_id=l3_domain_template_shared_infra.id))[0]
self.addCleanup(shared_l3_domain.delete)
zone = shared_l3_domain.zones.get_first()
shared_subnet = zone.create_child(
vspk.NUSubnet(name=utils.get_random_name(),
address=address,
netmask=netmask,
resource_type="FLOATING"))[0]
self.addCleanup(shared_subnet.delete)
return shared_subnet
def test_port_no_vport(self):
port_name = utils.get_random_name()
cmd_create = ('port create -f json --vnic-type=direct '
'--network {network} {name}'.format(
network=self.NETWORK_NAME, name=port_name))
cmd_output = json.loads(self.openstack(cmd_create))
self.assertEqual(expected='direct',
observed=cmd_output['binding_vnic_type'])
new_port_name = utils.get_random_name()
cmd_update = ('port set --name {} {}'.format(new_port_name, port_name))
cmd_output = self.openstack(cmd_update)
self.assertEqual(expected='', observed=cmd_output)
cmd_output = self._port_show(new_port_name)
self.assertEqual(expected='direct',
observed=cmd_output['binding_vnic_type'])
self.assertEqual(expected=new_port_name, observed=cmd_output['name'])
# delete and verify
utils.delete_and_verify(self, 'port', new_port_name)
def test_show_network_nuage_options(self):
network_name = utils.get_random_name()
cmd_create = 'network create -f json {name}'.format(name=network_name)
cmd_show = 'network show -f json {name}'.format(name=network_name)
for cmd in [cmd_create, cmd_show]:
cmd_output = json.loads(self.openstack(cmd))
self.assertIn(needle='nuage_l2bridge', haystack=cmd_output)
self.assertIsNone(observed=cmd_output['nuage_l2bridge'])
self.addCleanup(self.openstack,
'network delete {}'.format(network_name))
def _create_topology(self, network, cidr, is_l3=True):
user_enterprise = self.session.user.enterprises.get_first(
filter='name == "{}"'.format(utils.get_vsd_net_parition_name()))
# Create VSD managed subnet
if is_l3:
l3domain = utils.create_l3_domain(self, user_enterprise)
zone = l3domain.create_child(
vspk.NUZone(name=utils.get_random_name()))[0]
vsd_subnet = zone.create_child(
vspk.NUSubnet(name=utils.get_random_name(),
address=str(cidr.ip),
netmask=str(cidr.netmask)))[0]
else:
l3domain = None
vsd_subnet = utils.create_l2_domain(self,
user_enterprise,
address=str(cidr.ip),
netmask=str(cidr.netmask),
gateway=str(cidr.ip + 1))
subnet_create_str = ('subnet create -f json --network {network} '
'--net-partition {net_partition} '
'--nuagenet {nuagenet} '
'--subnet-range {subnet_range} {subnet_name}')
if not is_l3:
subnet_create_str += ' --gateway None'
cmd_create = subnet_create_str.format(
network=network,
net_partition=user_enterprise.id,
nuagenet=vsd_subnet.id,
subnet_range=cidr,
subnet_name=utils.get_random_name())
subnet = json.loads(self.openstack(cmd_create))
self.addCleanup(self.openstack,
'subnet delete {}'.format(subnet['id']))
return subnet, l3domain or vsd_subnet
def test_show_list(self):
"""Create, delete a port with a nuage floating ip"""
# Create Nuage floating ips
floating_ip_str_1 = '1.1.1.50'
floating_ip_str_2 = '1.1.1.60'
floating_ip_1 = self._create_nuage_floating_ip(floating_ip_str_1)
self.addCleanup(floating_ip_1.delete)
floating_ip_2 = self._create_nuage_floating_ip(floating_ip_str_2)
self.addCleanup(floating_ip_2.delete)
expected_1 = {'ID': floating_ip_1.id,
'Assigned': False,
'Floating_ip_address': floating_ip_str_1}
expected_2 = {'ID': floating_ip_2.id,
'Assigned': False,
'Floating_ip_address': floating_ip_str_2}
# Show and verify
cmd_output_show = self._nuage_floatingip_show(floating_ip_2.id)
self.assertEqual(expected={k.lower(): v
for k, v in expected_2.items()},
observed=cmd_output_show)
# Attach a floating ip to the port
port_name = utils.get_random_name()
self.openstack(('port create -f json --network {network} {name}'
.format(network=self.network_name, name=port_name)))
self.addCleanup(self.openstack, 'port delete {}'.format(port_name))
self.openstack('port set --nuage-floatingip {fip} {port}'.format(
fip=expected_1['ID'], port=port_name))
expected_1['Assigned'] = True
# List and verify
cmd_output_list = self._nuage_floatingip_list()
self.assertIn(needle=expected_1, haystack=cmd_output_list)
self.assertIn(needle=expected_2, haystack=cmd_output_list)
cmd_output_list = self._nuage_floatingip_list(for_port=port_name)
self.assertEqual(expected=[expected_2],
observed=cmd_output_list)
cmd_output_list = self._nuage_floatingip_list(
for_subnet=self.openstack_subnet['id'])
self.assertEqual(expected=[expected_2],
observed=cmd_output_list)
def test_vsd_managed_crud(self):
session = create_new_vspk_session()
enterprise = session.user.enterprises.get_first(
filter='name == "{}"'.format(get_vsd_net_parition_name()))
subnet_name = get_random_name()
ip_config = get_random_ipv4_subnet_config()
l2domain = create_l2_domain(self, enterprise, ip_config['address'],
ip_config['netmask'], ip_config['gateway'])
# CREATE / READ
cmd_create = ('subnet create -f json --network {network} '
'--net-partition {net_partition} --nuagenet {nuagenet} '
'--subnet-range {subnet_range} {subnet_name} '
'--gateway None'
.format(network=self.NETWORK_NAME,
net_partition=enterprise.id,
nuagenet=l2domain.id,
subnet_range=ip_config['cidr'],
subnet_name=subnet_name))
cmd_show = 'subnet show -f json {}'.format(subnet_name)
for cmd in [cmd_create, cmd_show]:
cmd_output = json.loads(self.openstack(cmd))
self.assertEqual(expected=True,
observed=cmd_output['vsd_managed'])
self.assertEqual(expected=subnet_name,
observed=cmd_output['name'])
self.assertEqual(expected=l2domain.id,
observed=cmd_output['nuagenet'])
self.assertEqual(expected=enterprise.id,
observed=cmd_output['net_partition'])
self.assertEqual(expected=ip_config['cidr'],
observed=cmd_output['cidr'])
# UPDATE
update_cmd = 'subnet set --nuage-underlay route {}'.format(subnet_name)
try:
self.openstack(update_cmd)
except exceptions.CommandFailed as e:
self.assertIn(needle='is a VSD-managed subnet. Update is not '
'supported for attributes other than ',
haystack=str(e.stderr))
else:
self.assertIsNotNone(None, message="Update command should fail.")
# DELETE
delete_and_verify(self, 'subnet', subnet_name)
def _create_network(self):
network_name = utils.get_random_name()
return json.loads(
self.openstack('network create -f json {}'.format(network_name)))
def test_list_show_switchport_binding(self):
# create a switchport binding
host_id = 'fake_host_id'
pci_slot = '0000:03:10.6'
vlan = 123
binding_profile = dict(pci_slot=pci_slot,
physical_network='physnet1',
pci_vendor_info='8086:10ed')
self.create_and_verify_switchport_mapping(host_id=host_id,
pci_slot=pci_slot,
switch_id=self.system_id,
port_id=self.gw_port_name,
switch_info=self.name)
network_name = utils.get_random_name()
self.openstack('network create --mtu 1400 --provider-network-type vlan'
' --provider-physical-network physnet1'
' --provider-segment {vlan} {network}'.format(
vlan=vlan, network=network_name))
self.addCleanup(self.openstack,
'network delete {}'.format(network_name))
segment_name = utils.get_random_name()
self.openstack('network segment create --network-type vxlan '
'--segment {vlan} --network {network} {segment}'.format(
vlan=vlan,
network=network_name,
segment=segment_name))
self.addCleanup(self.openstack,
'network segment delete {}'.format(segment_name))
subnet_name = utils.get_random_name()
self.openstack(('subnet create --network {network} --subnet-range '
'10.0.0.1/24 {subnet}'.format(network=network_name,
subnet=subnet_name)))
self.addCleanup(self.openstack, 'subnet delete {}'.format(subnet_name))
port_name = utils.get_random_name()
port_cmd_output = json.loads(
self.openstack(
("port create -f json --network {network} --vnic-type direct "
"--binding-profile '{binding_profile}' --host {host} {port}".
format(network=network_name,
binding_profile=json.dumps(binding_profile),
host=host_id,
port=port_name))))
self.addCleanup(self.openstack,
'port delete {}'.format(port_cmd_output['id']))
# list
cmd_output = json.loads(
self.openstack('nuage switchport binding list -f json'))
item = next((m for m in cmd_output
if m['Neutron port ID'] == port_cmd_output['id']), None)
self.assertIsNotNone(item)
self.assertEqual(expected=5, observed=len(item))
self.assertIsNotNone(item['ID'])
self.assertEqual(expected=item['Switch ID'], observed=self.system_id)
self.assertEqual(expected=item['Port ID'], observed=self.gw_port_name)
self.assertEqual(expected=item['Segmentation ID'], observed=vlan)
# show
cmd_output = json.loads(
self.openstack('nuage switchport binding show {} -f json'.format(
item['ID'])))
self.assertIsNotNone(cmd_output)
self.assertEqual(expected=7, observed=len(cmd_output))
self.assertIsNotNone(cmd_output['id'])
self.assertEqual(expected=cmd_output['neutron_port_id'],
observed=port_cmd_output['id'])
self.assertIsNotNone(cmd_output['nuage_vport_id'])
self.assertIsNotNone(cmd_output['port_uuid'])
self.assertEqual(expected=cmd_output['switch_id'],
observed=self.system_id)
self.assertEqual(expected=cmd_output['port_id'],
observed=self.gw_port_name)
self.assertEqual(expected=cmd_output['segmentation_id'], observed=vlan)
def test_nuage_floating_ip_option(self):
"""Create, delete a port with a nuage floating ip"""
# Create Nuage floating ip
shared_subnet = self._create_shared_fip_subnet(self.session, '1.1.1.0',
'255.255.255.0')
floating_ip_str = '1.1.1.10'
floating_ip = self.l3domain.create_child(
vspk.NUFloatingIp(
associated_shared_network_resource_id=shared_subnet.id,
address=floating_ip_str))[0]
self.addCleanup(floating_ip.delete)
# Create a port with the Nuage floating ip in the VSD managed subnet
port_name = utils.get_random_name()
cmd_create = ('port create -f json --nuage-floatingip {floating_ip} '
'--network {network} {name}'.format(
floating_ip=floating_ip_str,
network=self.NETWORK_NAME,
name=port_name))
cmd_output = json.loads(self.openstack(cmd_create))
self.addCleanup(self.openstack, 'port delete {}'.format(port_name))
# Verify create
self.assertIsNotNone(cmd_output.get('nuage_floatingip'))
self.assertEqual(observed=cmd_output['nuage_floatingip'],
expected=osc_utils.format_dict({
'id':
floating_ip.id,
'floating_ip_address':
floating_ip_str
}))
# Verify show
cmd_output = self._port_show(port_name)
self.assertEqual(observed=cmd_output['nuage_floatingip'],
expected=osc_utils.format_dict({
'id':
floating_ip.id,
'floating_ip_address':
floating_ip_str
}))
# Try to create again, expect failure
cmd_create = ('port create -f json --nuage-floatingip {floating_ip} '
'--network {network} {name}'.format(
floating_ip=floating_ip_str,
network=self.NETWORK_NAME,
name=utils.get_random_name()))
self.assertRaisesRegex(Exception, "Floating IP .* is already in use",
self.openstack, cmd_create)
# Verify set / unset
cmd_set = 'port set --nuage-floatingip 1.1.1.99 {}'.format(port_name)
self.assertRaisesRegex(
Exception, 'No Nuage Floating IP available with'
' IP 1.1.1.99', self.openstack, cmd_set)
port_name_2 = utils.get_random_name()
self.openstack('port create -f json --network {network} {name}'.format(
network=self.NETWORK_NAME, name=port_name_2))
cmd_set = 'port set --nuage-floatingip {} {}'.format(
floating_ip_str, port_name_2)
self.assertRaisesRegex(
Exception,
'Floating IP {} is already in use'.format(floating_ip_str),
self.openstack, cmd_set)
cmd_unset = 'port unset --nuage-floatingip {}'.format(port_name)
self.openstack(cmd_unset)
# Verify show (No Nuage floating ip)
cmd_output = self._port_show(port_name)
self.assertIsNone(cmd_output['nuage_floatingip'])
# the set should work now, since we unsetted the previous fip
self.openstack(cmd_set)
# Verify delete
utils.delete_and_verify(self, 'port', port_name_2)
def test_nuage_options(self):
# TODO(glenn) Test nuage-net-partition when the resource is implemented
# Create a router with Nuage arguments and verify using router show
router_name = utils.get_random_name()
args_for_create = {
'nuage_router_template': self._create_l3_domain_template().id,
'nuage_rd': self._random_target(),
'nuage_rt': self._random_target(),
'nuage_backhaul_vnid': 12345678,
'nuage_backhaul_rd': self._random_target(),
'nuage_backhaul_rt': self._random_target(),
'nuage_tunnel_type': 'GRE',
'nuage_ecmp_count': 3,
'nuage_underlay': 'snat'
}
cmd_create = ('router create -f json {args} {name}'.format(
args=self._build_arg_str(args_for_create), name=router_name))
cmd_show = 'router show -f json {}'.format(router_name)
for cmd in [cmd_create, cmd_show]:
cmd_output = json.loads(self.openstack(cmd))
self._verify(expected=dict(args_for_create, name=router_name),
observed=cmd_output)
# Set Nuage arguments and verify using router show
# a. update a property and check that the other ones did not change
args_for_set = {'nuage_ecmp_count': 4}
cmd_set = ('router set {args} {router}'.format(
args=self._build_arg_str(args_for_set), router=router_name))
cmd_output = self.openstack(cmd_set)
self.assertEqual(expected='', observed=cmd_output)
cmd_show = 'router show -f json {}'.format(router_name)
cmd_output = json.loads(self.openstack(cmd_show))
self._verify(expected=dict(args_for_create, **args_for_set),
observed=cmd_output)
# b. update all properties
args_for_set = {
'nuage_rd': self._random_target(),
'nuage_rt': self._random_target(),
'nuage_backhaul_vnid': 16777215,
'nuage_backhaul_rd': self._random_target(),
'nuage_backhaul_rt': self._random_target(),
'nuage_tunnel_type': 'VXLAN',
'nuage_ecmp_count': 4,
'nuage_underlay': 'route',
'name': utils.get_random_name()
}
cmd_set = ('router set {args} {router}'.format(
args=self._build_arg_str(args_for_set), router=router_name))
cmd_output = self.openstack(cmd_set)
self.assertEqual(expected='', observed=cmd_output)
cmd_show = 'router show -f json {}'.format(args_for_set['name'])
cmd_output = json.loads(self.openstack(cmd_show))
self._verify(expected=args_for_set, observed=cmd_output)
# Delete the router and verify using router list
utils.delete_and_verify(self, 'router', args_for_set['name'])
def test_nuage_policygroup_option(self):
# create policygroups
pg_names = [utils.get_random_name() for _ in range(2)]
pg_ids = [
self.l3domain.create_child(
vspk.NUPolicyGroup(name=pg_name, type='SOFTWARE'))[0].id
for pg_name in pg_names
]
# create port with the policygroup in the VSD managed subnet and verify
port_name = utils.get_random_name()
pgs_arg = ' '.join('--nuage-policy-group {}'.format(name)
for name in pg_names)
cmd_create = ('port create -f json {pgs_arg} '
'--network {network} {name}'.format(
pgs_arg=pgs_arg,
network=self.NETWORK_NAME,
name=port_name))
cmd_output = json.loads(self.openstack(cmd_create))
self.assertEqual(observed=cmd_output['nuage_policy_groups'],
expected=osc_utils.format_list(pg_ids))
# Set pg that is already set (nothing should change)
chosen_pg_id = random.choice(pg_ids)
cmd_set = 'port set --nuage-policy-group {pg_id} {port}'.format(
pg_id=chosen_pg_id, port=port_name)
cmd_output = self.openstack(cmd_set)
self.assertEqual(expected='', observed=cmd_output)
cmd_output = self._port_show(port_name)
self.assertEqual(expected=osc_utils.format_list(pg_ids),
observed=cmd_output['nuage_policy_groups'])
# Unset all and verify
cmd_no_pgs = 'port set --no-nuage-policy-groups {}'.format(port_name)
cmd_output = self.openstack(cmd_no_pgs)
self.assertEqual(expected='', observed=cmd_output)
cmd_output = self._port_show(port_name)
self.assertIsNone(cmd_output['nuage_policy_groups'])
# set all and verify
cmd_set_all = 'port set {pgs_arg} {name}'.format(pgs_arg=pgs_arg,
name=port_name)
cmd_output = self.openstack(cmd_set_all)
self.assertEqual(expected='', observed=cmd_output)
cmd_output = self._port_show(port_name)
self.assertEqual(expected=osc_utils.format_list(pg_ids),
observed=cmd_output['nuage_policy_groups'])
# unset one and verify
cmd_unset = ('port unset --nuage-policy-group {pg} {port}'.format(
pg=chosen_pg_id, port=port_name))
cmd_output = self.openstack(cmd_unset)
self.assertEqual(expected='', observed=cmd_output)
cmd_output = self._port_show(port_name)
self.assertEqual(observed=cmd_output['nuage_policy_groups'],
expected=osc_utils.format_list(
filter(lambda i: i != chosen_pg_id, pg_ids)))
# overwrite and verify
cmd_set = ('port set --no-nuage-policy-groups '
'--nuage-policy-group {} {}'.format(chosen_pg_id,
port_name))
cmd_output = self.openstack(cmd_set)
self.assertEqual(expected='', observed=cmd_output)
cmd_output = self._port_show(port_name)
self.assertEqual(expected=osc_utils.format_list([chosen_pg_id]),
observed=cmd_output['nuage_policy_groups'])
# set one and verify
pg_to_set = next(pg_id for pg_id in pg_ids if pg_id != chosen_pg_id)
cmd_set = ('port set --nuage-policy-group {pg} {port}'.format(
pg=pg_to_set, port=port_name))
cmd_output = self.openstack(cmd_set)
self.assertEqual(expected='', observed=cmd_output)
cmd_output = self._port_show(port_name)
self.assertEqual(expected=osc_utils.format_list(
[chosen_pg_id, pg_to_set]),
observed=cmd_output['nuage_policy_groups'])
# delete and verify
utils.delete_and_verify(self, 'port', port_name)
def __init__(self, *args, **kwargs):
super(NuageFloatingIPTests, self).__init__(*args, **kwargs)
self.l3domain = None
self.shared_subnet = None
self.network_name = utils.get_random_name()
self.openstack_subnet = None
