def __init__(self, vnName, displayName=None):
super(OpenContrailVN, self).__init__()
if displayName:
self.vnName = displayName
self.networkId = vnName
idPerm = vnc_api.IdPermsType(description=vnName)
self.obj = vnc_api.VirtualNetwork(name=displayName,
parent_obj=self.tenant,
id_perms=idPerm)
else:
self.vnName = vnName
self.obj = vnc_api.VirtualNetwork(name=vnName,
parent_obj=self.tenant)
def test_dup_project_new_unique_fqn(self):
logger.info('Creating first project in "keystone"')
proj_id = str(uuid.uuid4())
proj_name = self.id()
test_case.get_keystone_client().tenants.add_tenant(proj_id, proj_name)
proj_obj = self._vnc_lib.project_read(id=proj_id)
self.assertThat(proj_obj.name, Equals(proj_name))
# create a VN in it so old isn't removed (due to synchronous delete)
# when new with same name is created
vn_obj = vnc_api.VirtualNetwork('vn-%s' % (self.id()), proj_obj)
self._vnc_lib.virtual_network_create(vn_obj)
logger.info(
'Creating second project with same name diff id in "keystone"')
new_proj_id = str(uuid.uuid4())
test_case.get_keystone_client().tenants.add_tenant(
new_proj_id, proj_name)
new_proj_obj = self._vnc_lib.project_read(id=new_proj_id)
self.assertThat(new_proj_obj.name, Not(Equals(proj_name)))
self.assertThat(new_proj_obj.name, Contains(proj_name))
self.assertThat(new_proj_obj.display_name, Equals(proj_name))
self._vnc_lib.virtual_network_delete(id=vn_obj.uuid)
self._vnc_lib.project_delete(id=proj_id)
self._vnc_lib.project_delete(id=new_proj_id)
def create_fabric_network(vnc_test_client, vn_name, vn_key):
project = vnc_test_client.vnc_lib.project_read(
["default-domain", vnc_test_client.project_name])
fab_vn = vnc_api.VirtualNetwork(name=vn_name, parent_obj=project)
fab_vn.set_uuid(models.generate_uuid(vn_key))
vnc_test_client.vnc_lib.virtual_network_create(fab_vn)
return vnc_test_client.vnc_lib.virtual_network_read(id=fab_vn.uuid)
def create(self, name, subnet=None):
print "Inside VN Create"
fq_name = [self.domain, self.tenant, name]
try:
self.vnc_handle.virtual_network_read(fq_name=fq_name)
print "Virtual Network [{}] already exists".format(
self.fqn_to_string(fq_name))
sys.exit(1)
except vnc_exc.NoIdError:
print "Creating Virtual Network [{}]".format(
self.fqn_to_string(fq_name))
proj_obj = self.get_project()
self.vn_obj = vnc_api.VirtualNetwork(name=name,
parent_obj=proj_obj)
prop = vnc_api.VirtualNetworkType(
forwarding_mode='l2',
rpf='disable',
)
self.vn_obj.set_virtual_network_properties(prop)
self.vn_obj.set_flood_unknown_unicast(True)
(self.ipam_obj, self.ipam_subnet) = self.add_ipam()
self.vn_obj.set_network_ipam(ref_obj=self.ipam_obj,
ref_data=vnc_api.VnSubnetsType(
[self.ipam_subnet]))
self.vn_uuid = self.vnc_handle.virtual_network_create(self.vn_obj)
if self.vn_uuid:
print "Successfully created the virtual network [{}]".format(
self.fqn_to_string(fq_name))
return True
else:
print "Error: Cannot create the virtual network"
return False
def handle_create(self):
tenant_id = self.stack.context.tenant_id
project_obj = self.vnc_lib().project_read(id=str(uuid.UUID(tenant_id)))
vn_obj = vnc_api.VirtualNetwork(name=self.properties[self.NAME],
parent_obj=project_obj)
vn_params = vnc_api.VirtualNetworkType()
if self.properties[self.ALLOW_TRANSIT] == "True":
vn_params.set_allow_transit(True)
else:
vn_params.set_allow_transit(False)
vn_params.set_forwarding_mode(self.properties[self.FORWARDING_MODE])
vn_obj.set_virtual_network_properties(vn_params)
vn_obj.set_route_target_list(
vnc_api.RouteTargetList([
"target:" + route
for route in self.properties[self.ROUTE_TARGETS]
]))
if self.properties[self.SHARED] == "True":
vn_obj.set_is_shared(True)
else:
vn_obj.set_is_shared(False)
if self.properties[self.EXTERNAL] == "True":
vn_obj.set_router_external(True)
else:
vn_obj.set_router_external(False)
if self.properties[self.FLOOD_UNKNOWN_UNICAST] == "True":
vn_obj.set_flood_unknown_unicast(True)
else:
vn_obj.set_flood_unknown_unicast(False)
vn_uuid = super(ContrailVirtualNetwork, self).resource_create(vn_obj)
self.resource_id_set(vn_uuid)
def test_list_trunks(self):
vn = vnc_api.VirtualNetwork('%s-vn' % self.id(),
parent_obj=self.project)
self._vnc_lib.virtual_network_create(vn)
neutron_trunks = []
vmi_ids = []
for i in range(2):
vmi = vnc_api.VirtualMachineInterface('%s-vmi%d' % (self.id(), i),
parent_obj=self.project)
vmi.add_virtual_network(vn)
vmi_ids.append(self._vnc_lib.virtual_machine_interface_create(vmi))
neutron_trunks.append(
self.create_resource(
'trunk',
self.project_id,
extra_res_fields={
'name': '%s-trunk-%d' % (self.id(), i),
'tenant_id': self.project_id,
'port_id': vmi.uuid
},
), )
list_result = self.list_resource('trunk', self.project_id)
self.assertEquals(len(list_result), len(neutron_trunks))
self.assertEquals({r['id']
for r in list_result},
{r['id']
for r in neutron_trunks})
# Clean the resources
for i in range(2):
self.delete_resource('trunk', self.project_id,
neutron_trunks[i]['id'])
self._vnc_lib.virtual_machine_interface_delete(id=vmi_ids[i])
self._vnc_lib.virtual_network_delete(id=vn.uuid)
def _create_vn_ri_vmi(self, obj_count=1):
vn_objs = []
ipam_objs = []
ri_objs = []
vmi_objs = []
for i in range(obj_count):
vn_obj = vnc_api.VirtualNetwork('%s-vn-%s' % (self.id(), i))
ipam_obj = vnc_api.NetworkIpam('%s-ipam-%s' % (self.id(), i))
vn_obj.add_network_ipam(ipam_obj, vnc_api.VnSubnetsType())
self._vnc_lib.network_ipam_create(ipam_obj)
ipam_objs.append(ipam_obj)
self._vnc_lib.virtual_network_create(vn_obj)
vn_objs.append(vn_obj)
ri_obj = vnc_api.RoutingInstance('%s-ri-%s' % (self.id(), i),
parent_obj=vn_obj)
self._vnc_lib.routing_instance_create(ri_obj)
ri_objs.append(ri_obj)
vmi_obj = vnc_api.VirtualMachineInterface(
'%s-vmi-%s' % (self.id(), i), parent_obj=vnc_api.Project())
vmi_obj.add_virtual_network(vn_obj)
self._vnc_lib.virtual_machine_interface_create(vmi_obj)
vmi_objs.append(vmi_obj)
return vn_objs, ipam_objs, ri_objs, vmi_objs
def create_vn_obj(self, network_q):
if 'tenant_id' not in network_q:
self._raise_contrail_exception(
'BadRequest', resource='network',
msg="'tenant_id' is mandatory")
net_name = network_q.get('name', None)
project_id = self._project_id_neutron_to_vnc(network_q['tenant_id'])
try:
proj_obj = self._project_read(proj_id=project_id)
except vnc_exc.NoIdError:
self._raise_contrail_exception(
'ProjectNotFound', project_id=project_id, resource='network')
id_perms = vnc_api.IdPermsType(enable=True)
vn_obj = vnc_api.VirtualNetwork(net_name, proj_obj,
id_perms=id_perms)
external_attr = network_q.get('router:external')
if external_attr is not None:
vn_obj.router_external = external_attr
else:
vn_obj.router_external = False
is_shared = network_q.get('shared')
if is_shared is not None:
vn_obj.is_shared = is_shared
else:
vn_obj.is_shared = False
return vn_obj
def test_dup_project_fails(self):
logger.info('Creating first project in "keystone"')
proj_id = str(uuid.uuid4())
proj_name = self.id()
test_case.get_keystone_client().tenants.add_tenant(proj_id, proj_name)
proj_obj = self._vnc_lib.project_read(id=proj_id)
self.assertThat(proj_obj.name, Equals(proj_name))
# create a VN in it so old isn't removed (due to synchronous delete)
# when new with same name is created
vn_obj = vnc_api.VirtualNetwork('vn-%s' % (self.id()), proj_obj)
self._vnc_lib.virtual_network_create(vn_obj)
stale_mode = self.openstack_driver._resync_stale_mode
self.openstack_driver._resync_stale_mode = 'new_fails'
try:
logger.info(
'Creating second project with same name diff id in "keystone"')
new_proj_id = str(uuid.uuid4())
test_case.get_keystone_client().tenants.add_tenant(
new_proj_id, proj_name)
with ExpectedException(vnc_api.NoIdError):
self._vnc_lib.project_read(id=new_proj_id)
self._vnc_lib.virtual_network_delete(id=vn_obj.uuid)
self._vnc_lib.project_delete(id=proj_id)
finally:
self.openstack_driver._resync_stale_mode = stale_mode
def create_VirtualNetwork(network_name, network_subnet, network_mask, vnc, domain, project_name):
""" FUNCTION TO CREATE VIRTUAL-NETWORK """
project = vnc.project_read(fq_name = [domain, project_name])
vn_obj = vnc_api.VirtualNetwork(name=network_name, parent_obj=project)
vn_obj.add_network_ipam(vnc_api.NetworkIpam(),
vnc_api.VnSubnetsType([vnc_api.IpamSubnetType(subnet = vnc_api.SubnetType(network_subnet,network_mask))]))
vnc.virtual_network_create(vn_obj)
print 'Network "{}" created successfully\n'.format(network_name)
def test_trunk_create_with_same_vlan_tag_negative(self):
vn = vnc_api.VirtualNetwork('vn-same-vlan-tag-%s' % (self.id()))
self._vnc_lib.virtual_network_create(vn)
vmi_obj = vnc_api.VirtualMachineInterface('trunk-port-same-vlan-tag',
parent_obj=self.project)
vmi_obj.set_virtual_network(vn)
vmi_id = self._vnc_lib.virtual_machine_interface_create(vmi_obj)
sub_ports = []
for i in range(self.VMI_NUM):
sub_vmi_dict = {}
sub_vmi_obj = vnc_api.VirtualMachineInterface(
'sub-port-%s' % (i), parent_obj=self.project)
sub_vmi_obj.set_virtual_network(vn)
sub_port_id = self._vnc_lib.virtual_machine_interface_create(
sub_vmi_obj)
sub_vmi_dict['port_id'] = sub_port_id
sub_vmi_dict['segmentation_id'] = 10
sub_ports.append(sub_vmi_dict)
context = {
'operation': 'CREATE',
'user_id': '',
'is_admin': True,
'roles': ''
}
data = {
'resource': {
'name': 'trunk-%s' % (self.id()),
'tenant_id': self.project_id,
'port_id': vmi_id,
'sub_ports': sub_ports
}
}
body = {'context': context, 'data': data}
# Create Trunk should fail since sub ports have same vlan tag
try:
self._api_svr_app.post_json('/neutron/trunk', body)
except webtest.app.AppError as e:
self.assertIsNot(re.search('DuplicateSubPort', str(e)), None)
# Clean the resources
for i in range(self.VMI_NUM):
self._vnc_lib.virtual_machine_interface_delete(
id=sub_ports[i].get('port_id'))
self._vnc_lib.virtual_machine_interface_delete(id=vmi_id)
self._vnc_lib.virtual_network_delete(id=vn.uuid)
def test_trunk_crud(self):
vn = vnc_api.VirtualNetwork('vn-%s' % (self.id()))
self._vnc_lib.virtual_network_create(vn)
vmi_obj = vnc_api.VirtualMachineInterface('trunk-port',
parent_obj=self.project)
vmi_obj.set_virtual_network(vn)
vmi_id = self._vnc_lib.virtual_machine_interface_create(vmi_obj)
context = {
'operation': 'CREATE',
'user_id': '',
'is_admin': True,
'roles': ''
}
data = {
'resource': {
'name': 'trunk-%s' % (self.id()),
'tenant_id': self.project_id,
'port_id': vmi_id
}
}
body = {'context': context, 'data': data}
# Create Trunk
resp = self._api_svr_app.post_json('/neutron/trunk', body)
trunk_dict = json.loads(resp.text)
# Read Trunk
trunk_read_dict = self.read_resource('trunk', trunk_dict['id'])
self.assertEquals(trunk_dict['id'], trunk_read_dict['id'])
# Update Trunk
extra_res_fields = {'name': 'trunk_update'}
trunk_update_dict = self.update_resource(
'trunk',
trunk_dict['id'],
self.project_id,
extra_res_fields=extra_res_fields)
self.assertEquals(trunk_update_dict['name'], extra_res_fields['name'])
# Delete Trunk
self.delete_resource('trunk', self.project_id, trunk_dict['id'])
# Clean the resources
self._vnc_lib.virtual_machine_interface_delete(id=vmi_id)
self._vnc_lib.virtual_network_delete(id=vn.uuid)
def create_vn(self, vn_name, vn_subnetmask, vn_gw):
print "Create virtual_network %s" % vn_name
project = self._vnc_lib.project_read(
fq_name=[self._domain, self._tenant_name])
vn_obj = vnc_api.VirtualNetwork(name=vn_name, parent_obj=project)
vn_subnet = vn_subnetmask.split('/')[0]
vn_mask = int(vn_subnetmask.split('/')[1])
vn_obj.add_network_ipam(
vnc_api.NetworkIpam(),
vnc_api.VnSubnetsType([
vnc_api.IpamSubnetType(subnet=vnc_api.SubnetType(
vn_subnet, vn_mask),
default_gateway=vn_gw)
]))
self._vnc_lib.virtual_network_create(vn_obj)
def virtual_network_locate(vn_name):
fq_name = vn_name.split(':')
try:
vn_instance = client.virtual_network_read(fq_name=fq_name)
print "Virtual network '%s' already exists" % vn_name
return vn_instance
except vnc_api.NoIdError:
pass
vn_name = fq_name[2]
vn_instance = vnc_api.VirtualNetwork(vn_name)
vn_instance.add_network_ipam(
vnc_api.NetworkIpam(),
vnc_api.VnSubnetsType([
vnc_api.IpamSubnetType(subnet=vnc_api.SubnetType('20.1.1.0', 24))
]))
client.virtual_network_create(vn_instance)
print "Virtual network '%s' created" % vn_name
return vn_instance
def createVirtualNetwork(tenant, vnName, v4subnet, rt):
project = vnc_client.project_read(fq_name_str = 'default-domain:' + tenant)
vn = vnc_api.VirtualNetwork(name = vnName,
parent_obj = project)
ipam_obj = vnc_client.network_ipam_read(fq_name = ['default-domain',
'default-project', 'default-network-ipam'])
cidr = v4subnet.split('/')
subnet = vnc_api.SubnetType(ip_prefix = cidr[0],
ip_prefix_len = int(cidr[1]))
v4DnsServer = str(IPNetwork(v4subnet)[+2])
v4gateway = str(IPNetwork(v4subnet)[+1])
ipam_subnet = vnc_api.IpamSubnetType(subnet = subnet, dns_server_address = v4DnsServer,
default_gateway = v4gateway, enable_dhcp = False)
vn.add_network_ipam(ref_obj = ipam_obj,
ref_data = vnc_api.VnSubnetsType([ipam_subnet]))
rtObj = vnc_api.RouteTargetList()
vn.set_route_target_list(rtObj)
rtObj.add_route_target('target:%s' %(rt))
vnc_client.virtual_network_create(vn)
vnObj = vnc_client.virtual_network_read(fq_name_str = 'default-domain:' + tenant + ':' + vnName)
return vnObj
def test_add_parent_port_to_another_trunk_negative(self):
vn = vnc_api.VirtualNetwork('vn-%s' % (self.id()))
self._vnc_lib.virtual_network_create(vn)
vmi_obj = vnc_api.VirtualMachineInterface('trunk-port',
parent_obj=self.project)
vmi_obj.set_virtual_network(vn)
vmi_id = self._vnc_lib.virtual_machine_interface_create(vmi_obj)
context = {
'operation': 'CREATE',
'user_id': '',
'is_admin': True,
'roles': ''
}
data = {
'resource': {
'name': 'trunk-%s' % (self.id()),
'tenant_id': self.project_id,
'port_id': vmi_id
}
}
body = {'context': context, 'data': data}
resp = self._api_svr_app.post_json('/neutron/trunk', body)
trunk_dict = json.loads(resp.text)
try:
self.create_resource(
'trunk',
self.project_id,
extra_res_fields={
'name': 'trunk-negative-%s' % (self.id()),
'tenant_id': self.project_id,
'port_id': vmi_id
},
),
except webtest.app.AppError as e:
self.assertIsNot(re.search('TrunkPortInUse', str(e)), None)
self.delete_resource('trunk', self.project_id, trunk_dict['id'])
self._vnc_lib.virtual_machine_interface_delete(id=vmi_id)
def create(self):
"""Create a vm and vmi, find or create a network, and attach
the vmi to a new veth interface
Arguments:
vm_name name of the vm to create
net_name name of the netwok to arrach to
subnet x.x.x.x/len - optional if network already exists
netns Network namespace where the veth interface is bound to. Defaults to net_name
Returns:
A dict with the following elements:
port_id uuid of port
ip
veth name of veth interface
netns Network namespace where the veth interface is bound to
"""
# remember what to clean up if things go wrong
port_created = False
veth_created = False
netns_created = False
ip_created = False
vmi_created = False
vnet_created = False
vm_created = False
try:
# sanity check
net_name = self.args.get('net_name')
if not net_name:
raise ValueError("Network name argument is required")
# sanitize netns since it gets passed to the shell
netns = self.args.get('netns')
if not netns:
netns = net_name
if not re.match(r'^[-.\w]+$', netns):
raise ValueError("netns=[%s] must be a valid namespace name"
+ " (a single word)" % netns)
vnc_client = self.vnc_connect()
proj_fq_name = self.args['project'].split(':')
# find or create the VM
vm_fq_name = proj_fq_name + [ self.args['vm_name'] ]
# debug
#import pdb; pdb.set_trace()
try:
vm = vnc_client.virtual_machine_read(fq_name = vm_fq_name)
if vm:
raise ValueError(("Virtual machine named %s already exists."
+ " Use --delete to delete it")
% self.args['vm_name'])
except vnc_api.NoIdError:
# create vm if necessary
vm = vnc_api.VirtualMachine(':'.join(vm_fq_name),
fq_name=vm_fq_name)
vnc_client.virtual_machine_create(vm)
vm = vnc_client.virtual_machine_read(fq_name = vm_fq_name)
vm_created = True
# find or create the network
vnet_fq_name = proj_fq_name + [ net_name ]
vnet_created = False
try:
vnet = vnc_client.virtual_network_read(fq_name = vnet_fq_name)
except vnc_api.NoIdError:
# create the network if it doesn't exist
vnet = vnc_api.VirtualNetwork(vnet_fq_name[-1],
parent_type = 'project',
fq_name = vnet_fq_name)
# add a subnet
ipam = vnc_client.network_ipam_read(
fq_name = ['default-domain',
'default-project',
'default-network-ipam'])
(prefix, plen) = self.args['subnet'].split('/')
subnet = vnc_api.IpamSubnetType(
subnet = vnc_api.SubnetType(prefix, int(plen)))
vnet.add_network_ipam(ipam, vnc_api.VnSubnetsType([subnet]))
vnc_client.virtual_network_create(vnet)
vnet_created = True
# find or create the vmi
vmi_fq_name = vm.fq_name + ['0']
vmi_created = False
try:
vmi = vnc_client.virtual_machine_interface_read(
fq_name = vmi_fq_name)
except vnc_api.NoIdError:
vmi = vnc_api.VirtualMachineInterface(
parent_type = 'virtual-machine',
fq_name = vmi_fq_name)
vmi_created = True
vmi.set_virtual_network(vnet)
if vmi_created:
vnc_client.virtual_machine_interface_create(vmi)
else:
vnc_client.virtual_machine_interface_update(vmi)
# re-read the vmi to get its mac addresses
vmi = vnc_client.virtual_machine_interface_read(
fq_name = vmi_fq_name)
# create an IP for the VMI if it doesn't already have one
ips = vmi.get_instance_ip_back_refs()
if not ips:
ip = vnc_api.InstanceIp(vm.name + '.0')
ip.set_virtual_machine_interface(vmi)
ip.set_virtual_network(vnet)
ip_created = vnc_client.instance_ip_create(ip)
# Create the veth port. Create a veth pair. Put one end
# in the VMI port and the other in a network namespace
# get the ip, mac, and gateway from the vmi
ip_uuid = vmi.get_instance_ip_back_refs()[0]['uuid']
ip = vnc_client.instance_ip_read(id=ip_uuid).instance_ip_address
mac = vmi.virtual_machine_interface_mac_addresses.mac_address[0]
subnet = vnet.network_ipam_refs[0]['attr'].ipam_subnets[0]
gw = subnet.default_gateway
dns = gw # KLUDGE - that's the default, but some networks
# have other DNS configurations
ipnetaddr = netaddr.IPNetwork("%s/%s" %
(subnet.subnet.ip_prefix,
subnet.subnet.ip_prefix_len))
# set up the veth pair with one part for vrouter and one
# for the netns
# find a name that's not already used in the default or
# netns namespaces
link_exists = link_exists_func('', netns)
veth_vrouter = new_interface_name(suffix=vnet.uuid, prefix="ve1",
exists_func=link_exists)
veth_host = new_interface_name(suffix=vnet.uuid, prefix="ve0",
exists_func=link_exists)
sudo("ip link add %s type veth peer name %s",
(veth_vrouter, veth_host))
veth_created = True
try:
sudo("ip netns add %s", (netns,))
netns_created = True
except ProcessExecutionError:
pass
sudo("ip link set %s netns %s",
(veth_host, netns))
sudo("ip netns exec %s ip link set dev %s address %s",
(netns, veth_host, mac))
sudo("ip netns exec %s ip address add %s broadcast %s dev %s",
(netns,
("%s/%s" % (ip, subnet.subnet.ip_prefix_len)),
ipnetaddr.broadcast, veth_host))
sudo("ip netns exec %s ip link set dev %s up",
(netns, veth_host))
sudo("ip netns exec %s route add default gw %s dev %s",
(netns, gw, veth_host))
sudo("ip link set dev %s up", (veth_vrouter,))
# make a namespace-specific resolv.conf
resolv_conf = "/etc/netns/%s/resolv.conf" % netns
resolv_conf_body = "nameserver %s\n" % dns
sudo("mkdir -p %s", (os.path.dirname(resolv_conf),))
sudo("tee %s", (resolv_conf,), process_input=resolv_conf_body)
# finally, create the Contrail port
port = instance_service.ttypes.Port(
uuid_from_string(vmi.uuid),
uuid_from_string(vm.uuid),
veth_vrouter,
ip,
uuid_from_string(vnet.uuid),
mac,
)
rpc = vrouter_rpc()
rpc.AddPort([port])
port_created = True
return(dict(
port_id = uuid_array_to_str(port.port_id),
vm_id = vm.uuid,
net_id = vnet.uuid,
vmi_id = vmi.uuid,
veth = veth_host,
netns = netns,
ip = ip,
mac = mac,
gw = gw,
dns = dns,
netmask = str(ipnetaddr.netmask),
broadcast = str(ipnetaddr.broadcast),
))
except:
# something went wrong, clean up
if port_created:
rpc.DeletePort(port.port_id)
if veth_created:
sudo("ip link delete %s", (veth_vrouter,),
check_exit_code=False)
if netns_created:
sudo("ip netns delete %s", (netns,), check_exit_code=False)
if ip_created:
vnc_client.instance_ip_delete(id=ip_created)
if vmi_created:
vnc_client.virtual_machine_interface_delete(id=vmi.uuid)
if vnet_created:
vnc_client.virtual_network_delete(id=vnet.uuid)
if vm_created:
vnc_client.virtual_machine_delete(id=vm.uuid)
raise
def _vmi_to_neutron_port(self, vmi_obj, port_req_memo=None,
extensions_enabled=False, fields=None):
port_q_dict = {}
if not getattr(vmi_obj, 'display_name'):
# for ports created directly via vnc_api
port_q_dict['name'] = vmi_obj.get_fq_name()[-1]
else:
port_q_dict['name'] = vmi_obj.display_name
port_q_dict['id'] = vmi_obj.uuid
net_id = self.get_vmi_net_id(vmi_obj)
if not net_id:
# TODO() hack to force network_id on default port
# as neutron needs it
net_id = self._vnc_lib.obj_to_id(vnc_api.VirtualNetwork())
if port_req_memo is None:
# create a memo only for this port's conversion in this method
port_req_memo = {}
if 'networks' not in port_req_memo:
port_req_memo['networks'] = {}
if 'subnets' not in port_req_memo:
port_req_memo['subnets'] = {}
if 'virtual-machines' not in port_req_memo:
port_req_memo['virtual-machines'] = {}
try:
vn_obj = port_req_memo['networks'][net_id]
except KeyError:
vn_obj = self._vnc_lib.virtual_network_read(id=net_id)
port_req_memo['networks'][net_id] = vn_obj
subnets_info = (
subnet_handler.SubnetHandler.get_vn_subnets(vn_obj))
port_req_memo['subnets'][net_id] = subnets_info
if vmi_obj.parent_type != "project":
proj_id = self._project_id_vnc_to_neutron(vn_obj.parent_uuid)
else:
proj_id = self._project_id_vnc_to_neutron(vmi_obj.parent_uuid)
port_q_dict['tenant_id'] = proj_id
port_q_dict['network_id'] = net_id
# TODO() RHS below may need fixing
port_q_dict['mac_address'] = ''
mac_refs = vmi_obj.get_virtual_machine_interface_mac_addresses()
if mac_refs:
port_q_dict['mac_address'] = mac_refs.mac_address[0]
extra_dhcp_opts = self._get_extra_dhcp_opts(vmi_obj)
if extra_dhcp_opts:
port_q_dict['extra_dhcp_opts'] = extra_dhcp_opts
address_pairs = self._get_allowed_adress_pairs(vmi_obj)
if address_pairs:
port_q_dict['allowed_address_pairs'] = address_pairs
port_q_dict['fixed_ips'] = self.get_vmi_ip_dict(vmi_obj, vn_obj,
port_req_memo)
port_q_dict['security_groups'] = []
sg_refs = vmi_obj.get_security_group_refs()
# read the no rule sg
no_rule_sg = res_handler.SGHandler(
self._vnc_lib).get_no_rule_security_group()
for sg_ref in sg_refs or []:
if no_rule_sg and sg_ref['uuid'] == no_rule_sg.uuid:
# hide the internal sg
continue
port_q_dict['security_groups'].append(sg_ref['uuid'])
port_q_dict['admin_state_up'] = vmi_obj.get_id_perms().enable
device_id, device_owner = self._get_vmi_device_id_owner(vmi_obj,
port_req_memo)
port_q_dict['device_id'] = device_id
if device_owner is not None:
port_q_dict['device_owner'] = device_owner
else:
port_q_dict['device_owner'] = (
vmi_obj.get_virtual_machine_interface_device_owner() or '')
if port_q_dict['device_id']:
port_q_dict['status'] = constants.PORT_STATUS_ACTIVE
else:
port_q_dict['status'] = constants.PORT_STATUS_DOWN
if extensions_enabled:
extra_dict = {'contrail:fq_name': vmi_obj.get_fq_name()}
port_q_dict.update(extra_dict)
bindings_dict = self._get_port_bindings(vmi_obj)
for k,v in bindings_dict.items():
port_q_dict[k] = v
if fields:
port_q_dict = self._filter_res_dict(port_q_dict, fields)
return port_q_dict
def vnc_vn_2(project, ipam):
vnc_vn = vnc_api.VirtualNetwork(name='DPG2', parent=project)
vnc_vn.set_uuid('vnc-vn-uuid-2')
vnc_vn.set_network_ipam(ipam, None)
return vnc_vn
my_pis=[]
for pi in pi_list:
switch=str(pi[0])
phy_intf = str(pi[1])
my_pi=vh.physical_interface_read(fq_name=[u'default-global-system-config', str(switch), str(phy_intf)])
my_pis.append(my_pi)
my_vn_ids=[]
my_vmi_ids=[]
tag_list = [(1002, 'untagged')]
print ("Creating %s VNs"%no_of_vns)
for i in range(1, no_of_vns+1):
print ("Creating VN number %s"%i)
vn_name = 'vn_' + str(i)
ip_prefix = '193.168.' + str(i) + '.0'
dns_ip = '193.168.' + str(i) + '.254'
obj_0 = vnc_api.VirtualNetwork(name=vn_name,parent_obj=my_proj)
obj_1 = vnc_api.VnSubnetsType()
obj_2 = vnc_api.IpamSubnetType()
obj_3 = vnc_api.SubnetType()
obj_3.set_ip_prefix(ip_prefix)
obj_3.set_ip_prefix_len('24')
obj_2.set_subnet(obj_3)
obj_2.set_enable_dhcp(False)
obj_2.set_addr_from_start(True)
obj_2.set_dns_server_address(str(dns_ip))
obj_1.add_ipam_subnets(obj_2)
obj_0.add_network_ipam(my_ipam, obj_1)
obj_0.set_virtual_network_category('routed')
vn_id = vh.virtual_network_create(obj_0)
my_vn_ids.append(vn_id)
def __init__(self, vnName):
super(OpenContrailVN, self).__init__()
self.vnName = vnName
self.obj = vnc_api.VirtualNetwork(name=vnName, parent_obj=self.tenant)
from vnc_api import vnc_api
vnc_lib = vnc_api.VncApi(api_server_host='10.10.7.149')
vn_blue_obj = vnc_api.VirtualNetwork('vn-blue')
vn_blue_obj.add_network_ipam(vnc_api.NetworkIpam(),vnc_api.VnSubnetsType([vnc_api.IpamSubnetType(subnet = vnc_api.SubnetType('10.0.2.0', 24))]))
vnc_lib.virtual_network_create(vn_blue_obj)
vn_red_obj = vnc_api.VirtualNetwork('vn-red')
vn_red_obj.add_network_ipam(vnc_api.NetworkIpam(),vnc_api.VnSubnetsType([vnc_api.IpamSubnetType(subnet = vnc_api.SubnetType('10.0.3.0', 24))]))
vnc_lib.virtual_network_create(vn_red_obj)
policy_obj = vnc_api.NetworkPolicy('policy-red-blue',network_policy_entries = vnc_api.PolicyEntriesType([vnc_api.PolicyRuleType(direction='<>',action_list = vnc_api.ActionListType(simple_action='pass'), protocol = 'tcp',src_addresses = [vnc_api.AddressType(virtual_network = vn_blue_obj.get_fq_name_str())], src_ports = [vnc_api.PortType(-1, -1)],dst_addresses = [vnc_api.AddressType(virtual_network = vn_red_obj.get_fq_name_str())], dst_ports = [vnc_api.PortType(80, 80)])]))
vnc_lib.network_policy_create(policy_obj)
vn_blue_obj.add_network_policy(policy_obj, vnc_api.VirtualNetworkPolicyType(sequence=vnc_api.SequenceType(0, 0)))
vn_red_obj.add_network_policy(policy_obj, vnc_api.VirtualNetworkPolicyType(sequence=vnc_api.SequenceType(0, 0)))
vnc_lib.virtual_network_update(vn_blue_obj)
vnc_lib.virtual_network_update(vn_red_obj)
print vnc_lib.virtual_network_read(id = vn_blue_obj.uuid)
print vnc_lib.virtual_networks_list()
AS = '65000'
network_number = 1
ip = IPNetwork('172.24.0.0/16')
subnets = list(ip.subnet(24))
vnc = vnc_api.VncApi(username="******",
password="******",
tenant_name="admin",
api_server_host="Contrail_IP")
tenant = vnc.project_read(fq_name=['default-domain', 'vCenter'])
ipam = vnc.network_ipam_read(
fq_name=['default-domain', 'vCenter', 'vCenter-ipam'])
for subnet in subnets:
start_addr = str(subnet[10])
end_addr = str(subnet[100])
vn = vnc_api.VirtualNetwork(name="Customer_" + str(network_number),
parent_obj=tenant)
cidr = str(subnet)
print subnet, "RD", str(AS) + ":" + str(network_number)
prefix, prefix_len = cidr.split('/')
subnet = vnc_api.SubnetType(ip_prefix=prefix, ip_prefix_len=prefix_len)
alloc_pools = []
alloc_pools.append(
vnc_api.AllocationPoolType(start=start_addr, end=end_addr))
ipam_subnet = vnc_api.IpamSubnetType(subnet=subnet,
advertise_default=True,
allocation_pools=alloc_pools)
vn.set_network_ipam(ref_obj=ipam,
ref_data=vnc_api.VnSubnetsType([ipam_subnet]))
route_targets = vnc_api.RouteTargetList(
['target:' + str(AS) + ":" + str(network_number)])
vn.set_route_target_list(route_targets)
def test_trunk_add_and_delete_sub_ports(self):
vn = vnc_api.VirtualNetwork('vn-%s' % (self.id()))
self._vnc_lib.virtual_network_create(vn)
vmi_obj = vnc_api.VirtualMachineInterface('trunk-port',
parent_obj=self.project)
vmi_obj.set_virtual_network(vn)
vmi_id = self._vnc_lib.virtual_machine_interface_create(vmi_obj)
context = {
'operation': 'CREATE',
'user_id': '',
'is_admin': True,
'roles': ''
}
data = {
'resource': {
'name': 'trunk-%s' % (self.id()),
'tenant_id': self.project_id,
'port_id': vmi_id
}
}
body = {'context': context, 'data': data}
resp = self._api_svr_app.post_json('/neutron/trunk', body)
trunk_dict = json.loads(resp.text)
sub_port = vnc_api.VirtualMachineInterface('trunk-sub-port-%s' %
(self.id()),
parent_obj=self.project)
vmi_prop = vnc_api.VirtualMachineInterfacePropertiesType(
sub_interface_vlan_tag=10)
sub_port.set_virtual_machine_interface_properties(vmi_prop)
sub_port.set_virtual_network(vn)
sub_port_id = self._vnc_lib.virtual_machine_interface_create(sub_port)
neutron_trunk = self._add_subports(self.project_id, trunk_dict['id'],
sub_port_id)
self.assertEquals(neutron_trunk['sub_ports'][0].get('port_id'),
sub_port.uuid)
sub_port_neg = vnc_api.VirtualMachineInterface(
'trunk-sub-port-neg-%s' % (self.id()), parent_obj=self.project)
sub_port_neg.set_virtual_network(vn)
sub_port_id_neg = self._vnc_lib.virtual_machine_interface_create(
sub_port_neg)
# Adding sub port with the vlan tag that already exists in a trunk
# should return an exception.
try:
self._add_subports(self.project_id,
trunk_dict['id'],
sub_port_id_neg,
vlan_tag=10)
except webtest.app.AppError as e:
self.assertIsNot(re.search('DuplicateSubPort', str(e)), None)
neutron_trunk = self._remove_subports(self.project_id,
trunk_dict['id'], sub_port_id)
self.assertEquals(neutron_trunk['sub_ports'], [])
# Clean the resources
self.delete_resource('trunk', self.project_id, trunk_dict['id'])
self._vnc_lib.virtual_machine_interface_delete(id=sub_port_id)
self._vnc_lib.virtual_machine_interface_delete(id=sub_port_id_neg)
self._vnc_lib.virtual_machine_interface_delete(id=vmi_id)
self._vnc_lib.virtual_network_delete(id=vn.uuid)
def vn(project, vmi_1):
vn = vnc_api.VirtualNetwork(name="dvs-1_dpg-1", parent_obj=project)
vn.set_uuid(models.generate_uuid("dvportgroup-1"))
vn.set_id_perms(constants.ID_PERMS)
vn.virtual_machine_interface_back_refs = [{"uuid": vmi_1.uuid}]
return vn
def fabric_vn(project):
vn = vnc_api.VirtualNetwork(name="dvs-1_dpg-1", parent_obj=project)
vn.set_uuid(models.generate_uuid("dvportgroup-1"))
return vn
def to_vnc_vn(self, project):
vnc_name = self.get_vnc_name(self.dvs_name, self.name)
vnc_vn = vnc_api.VirtualNetwork(name=vnc_name, parent_obj=project)
vnc_vn.set_uuid(self.uuid)
vnc_vn.set_id_perms(const.ID_PERMS)
return vnc_vn
