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