def _create_vm(self, pod_namespace, pod_id, pod_name, labels, proj_uuid):
cluster_name = vnc_kube_config.cluster_name()
vm_name = VncCommon.make_name(cluster_name, pod_namespace, pod_name)
display_name = vm_name
self._check_pod_uuid_change(pod_id, vm_name)
perms2 = PermType2()
perms2.owner = proj_uuid
perms2.owner_access = cfgm_common.PERMS_RWX
vm_obj = VirtualMachine(name=vm_name,
perms2=perms2,
display_name=display_name)
vm_obj.uuid = pod_id
vm_obj.set_server_type("container")
VirtualMachineKM.add_annotations(self,
vm_obj,
pod_namespace,
pod_name,
k8s_uuid=str(pod_id),
labels=json.dumps(labels))
try:
self._vnc_lib.virtual_machine_create(vm_obj)
except RefsExistError:
vm_obj = self._vnc_lib.virtual_machine_read(id=pod_id)
VirtualMachineKM.locate(vm_obj.uuid)
return vm_obj
def test_vm_port_not_added_to_lr(self):
project = self._vnc_lib.project_read(
['default-domain', 'default-project'])
ipam = self._vnc_lib.network_ipam_read(
['default-domain', 'default-project', 'default-network-ipam'])
# Create subnets
ipam_sn_v4_vn = IpamSubnetType(subnet=SubnetType('11.1.1.0', 24))
# Create VN my-vn
vn = VirtualNetwork('%s-vn' % self.id(), project)
vn.add_network_ipam(ipam, VnSubnetsType([ipam_sn_v4_vn]))
self._vnc_lib.virtual_network_create(vn)
net_obj = self._vnc_lib.virtual_network_read(id=vn.uuid)
# Create v4 Ip object
ip_obj = InstanceIp(name=str(uuid.uuid4()), instance_ip_family='v4')
ip_obj.uuid = ip_obj.name
# Create VM
vm_inst_obj = VirtualMachine(str(uuid.uuid4()))
vm_inst_obj.uuid = vm_inst_obj.name
self._vnc_lib.virtual_machine_create(vm_inst_obj)
id_perms = IdPermsType(enable=True)
vm_port_obj = VirtualMachineInterface(str(uuid.uuid4()),
vm_inst_obj,
id_perms=id_perms)
vm_port_obj.uuid = vm_port_obj.name
vm_port_obj.set_virtual_network(vn)
ip_obj.set_virtual_machine_interface(vm_port_obj)
ip_obj.set_virtual_network(net_obj)
self._vnc_lib.virtual_machine_interface_create(vm_port_obj)
self._vnc_lib.instance_ip_create(ip_obj)
# Create Logical Router
lr = LogicalRouter('router-test-v4-%s' % self.id(), project)
self._vnc_lib.logical_router_create(lr)
# Add Router Interface
lr.add_virtual_machine_interface(vm_port_obj)
with ExpectedException(RefsExistError):
self._vnc_lib.logical_router_update(lr)
lr.del_virtual_machine_interface(vm_port_obj)
# Create Port
port_obj = self.create_port(project, net_obj)
lr.add_virtual_machine_interface(port_obj)
self._vnc_lib.logical_router_update(lr)
with ExpectedException(BadRequest):
port_obj.add_virtual_machine(vm_inst_obj)
self._vnc_lib.virtual_machine_interface_update(port_obj)
self._vnc_lib.logical_router_delete(id=lr.uuid)
def _create_vmi(self, vmi_name, vn_obj, mac='00:11:22:33:44:55'):
vm_name = vmi_name + '_test_vm'
vm = VirtualMachine(vm_name)
vm_uuid = self._vnc_lib.virtual_machine_create(vm)
vm_obj = self._vnc_lib.virtual_machine_read(id=vm_uuid)
vmi = VirtualMachineInterface(
name=vmi_name,
parent_obj=vm_obj,
virtual_machine_interface_mac_address=mac)
vmi.add_virtual_network(vn_obj)
vmi_uuid = self._vnc_lib.virtual_machine_interface_create(vmi)
vmi_obj = self._vnc_lib.virtual_machine_interface_read(id=vmi_uuid)
return vmi_obj
def _add_pod_to_service(self, service_id, pod_id, port=None, address=None):
lb = LoadbalancerKM.get(service_id)
if not lb:
return
vm = VirtualMachineKM.get(pod_id)
host_vmi = None
if not vm:
if not self._args.host_network_service:
return
host_vmi = self._get_vmi_from_ip(address)
if host_vmi is None:
return
else:
vm = VirtualMachine(name="host", display_name="host")
vm.virtual_machine_interfaces = [host_vmi]
for lb_listener_id in lb.loadbalancer_listeners:
pool = self._get_loadbalancer_pool(lb_listener_id, port)
if not pool:
continue
for vmi_id in vm.virtual_machine_interfaces:
vmi = VirtualMachineInterfaceKM.get(vmi_id)
if not vmi:
continue
if host_vmi is None:
# Add VMI only if it matches the default address for endpoint,
# ignore other interfaces for pod
ip_found = False
for iip_uuid in vmi.instance_ips:
iip = InstanceIpKM.get(iip_uuid)
if iip and iip.address == address:
ip_found = True
break
if not ip_found:
continue
for member_id in pool.members:
member = LoadbalancerMemberKM.get(member_id)
if member and member.vmi == vmi_id:
break
else:
self.logger.debug(
"Creating LB member for Pod/VM: %s in LB: %s with "
"target-port: %d" %
(vm.fq_name, lb.name, port['port']))
member_obj = self._vnc_create_member(
pool, pod_id, vmi_id, port['port'])
vmi_obj = self._vnc_lib.virtual_machine_interface_read(
id=vmi_id)
# Attach the service label to underlying pod vmi.
self._labels.append(
vmi_id,
self._labels.get_service_label(lb.service_name))
# Set tags on the vmi.
self._vnc_lib.set_tags(
vmi_obj, self._labels.get_labels_dict(vmi_id))
LoadbalancerMemberKM.locate(member_obj.uuid)