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 _create_vm(self, pod_namespace, pod_id, pod_name, labels):
vm_name = VncCommon.make_name(pod_name, pod_id)
display_name = VncCommon.make_display_name(pod_namespace, pod_name)
vm_obj = VirtualMachine(name=vm_name, display_name=display_name)
vm_obj.uuid = pod_id
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 _create_vm(self, pod_namespace, pod_id, pod_name, labels):
vm_name = VncCommon.make_name(pod_name, pod_id)
display_name = VncCommon.make_display_name(pod_namespace, pod_name)
vm_obj = VirtualMachine(name=vm_name, display_name=display_name)
vm_obj.uuid = pod_id
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 _link_vm_to_node(self, vm_obj, pod_node, node_ip):
if node_ip is None:
return
vm = VirtualMachineKM.locate(vm_obj.uuid)
if vm:
vm.node_ip = node_ip
vr_uuid = VirtualRouterKM.get_ip_addr_to_uuid(node_ip)
if vr_uuid is None:
self._logger.debug("%s - Vrouter %s Not Found for Pod %s"
%(self._name, node_ip, vm_obj.uuid))
return
try:
vrouter_obj = self._vnc_lib.virtual_router_read(id=vr_uuid)
except Exception as e:
self._logger.debug("%s - Vrouter %s Not Found for Pod %s"
%(self._name, node_ip, vm_obj.uuid))
string_buf = StringIO()
cgitb_hook(file=string_buf, format="text")
err_msg = string_buf.getvalue()
self._logger.error("_link_vm_to_node: %s - %s" %(self._name, err_msg))
return
self._vnc_lib.ref_update('virtual-router', vrouter_obj.uuid,
'virtual-machine', vm_obj.uuid, None, 'ADD')
if vm:
vm.virtual_router = vr_obj.uuid
def _link_vm_to_node(self, vm_obj, pod_node, node_ip):
if node_ip is None:
return
vm = VirtualMachineKM.locate(vm_obj.uuid)
if vm:
vm.node_ip = node_ip
vr_uuid = VirtualRouterKM.get_ip_addr_to_uuid(node_ip)
if vr_uuid is None:
for vr in VirtualRouterKM.values():
if vr.name == pod_node:
vr_uuid = vr.uuid
if vr_uuid is None:
self._logger.debug("%s - Vrouter %s Not Found for Pod %s"
%(self._name, node_ip, vm_obj.uuid))
return
try:
vrouter_obj = self._vnc_lib.virtual_router_read(id=vr_uuid)
except Exception as e:
self._logger.debug("%s - Vrouter %s Not Found for Pod %s"
%(self._name, node_ip, vm_obj.uuid))
string_buf = StringIO()
cgitb_hook(file=string_buf, format="text")
err_msg = string_buf.getvalue()
self._logger.error("_link_vm_to_node: %s - %s" %(self._name, err_msg))
return
self._vnc_lib.ref_update('virtual-router', vrouter_obj.uuid,
'virtual-machine', vm_obj.uuid, None, 'ADD')
if vm:
vm.virtual_router = vrouter_obj.uuid
def vnc_pod_add(self, pod_id, pod_name, pod_namespace, pod_node, node_ip,
labels, vm_vmi):
vm = VirtualMachineKM.get(pod_id)
if vm:
vm.pod_namespace = pod_namespace
if not vm.virtual_router:
self._link_vm_to_node(vm, pod_node, node_ip)
self._set_label_to_pod_cache(labels, vm)
# Update tags.
self._set_tags_on_pod_vmi(pod_id)
return vm
else:
self._check_pod_uuid_change(pod_id, pod_name)
vn_obj = self._get_default_network(pod_id, pod_name, pod_namespace)
if not vn_obj:
return
pod = PodKM.find_by_name_or_uuid(pod_id)
total_interface_count = len(pod.networks) + 1
# network_status: Dict of network name to vmi_uuid
network_status = {}
vm_obj = self._create_vm(pod_namespace, pod_id, pod_name, labels)
index = str(0) + "/" + str(total_interface_count)
vmi_uuid = self.vnc_pod_vmi_create(pod_id, pod_name, pod_namespace,\
pod_node, node_ip, vm_obj, vn_obj, vm_vmi,\
index, nw_name='default')
network_status['cluster-wide-default'] = vmi_uuid
for idx, network_name in enumerate(pod.networks, start=1):
net_namespace = pod_namespace
net_name = network_name
# Check if network is in a different namespace than the pod's
# namespace (ex: <namespace/<network>)
if '/' in network_name:
net_namespace, net_name = network_name.split('/')
vn_obj = self._get_user_defined_network(net_name, net_namespace)
index = str(idx) + "/" + str(total_interface_count)
vmi_uuid = self.vnc_pod_vmi_create(pod_id, pod_name, net_namespace,\
pod_node, node_ip, vm_obj, vn_obj, vm_vmi,\
index, nw_name=net_name)
network_status[net_name] = vmi_uuid
if not self._is_pod_nested():
self._link_vm_to_node(vm_obj, pod_node, node_ip)
vm = VirtualMachineKM.locate(pod_id)
if vm:
vm.pod_namespace = pod_namespace
vm.pod_node = pod_node
vm.node_ip = node_ip
self._set_label_to_pod_cache(labels, vm)
self._set_tags_on_pod_vmi(pod_id)
# Update network-status in pod description
self._update_network_status(pod_name, pod_namespace, network_status)
return vm
def vnc_pod_add(self, pod_id, pod_name, pod_namespace, pod_node, node_ip,
labels, vm_vmi):
vm = VirtualMachineKM.get(pod_id)
if vm:
vm.pod_namespace = pod_namespace
if not vm.virtual_router:
self._link_vm_to_node(vm, pod_node, node_ip)
self._set_label_to_pod_cache(labels, vm)
return vm
else:
self._check_pod_uuid_change(pod_id, pod_name)
vn_obj = self._get_network(pod_id, pod_name, pod_namespace)
if not vn_obj:
return
vm_obj = self._create_vm(pod_namespace, pod_id, pod_name, labels)
vmi_uuid = self._create_vmi(pod_name, pod_namespace, vm_obj, vn_obj,
vm_vmi)
vmi = VirtualMachineInterfaceKM.get(vmi_uuid)
if self._is_pod_nested() and vm_vmi:
# Pod is nested.
# Link the pod VMI to the VMI of the underlay VM.
self._vnc_lib.ref_update('virtual-machine-interface', vm_vmi.uuid,
'virtual-machine-interface', vmi_uuid,
None, 'ADD')
self._vnc_lib.ref_update('virtual-machine-interface', vmi_uuid,
'virtual-machine-interface', vm_vmi.uuid,
None, 'ADD')
# get host id for vm vmi
vr_uuid = None
for vr in VirtualRouterKM.values():
if vr.name == vm_vmi.host_id:
vr_uuid = vr.uuid
break
if not vr_uuid:
self._logger.error(
"No virtual-router object found for host: " +
vm_vmi.host_id + ". Unable to add VM reference to a" +
" valid virtual-router")
return
self._vnc_lib.ref_update('virtual-router', vr_uuid,
'virtual-machine', vm_obj.uuid, None,
'ADD')
self._create_iip(pod_name, pod_namespace, vn_obj, vmi)
if not self._is_pod_nested():
self._link_vm_to_node(vm_obj, pod_node, node_ip)
vm = VirtualMachineKM.locate(pod_id)
if vm:
vm.pod_namespace = pod_namespace
vm.pod_node = pod_node
vm.node_ip = node_ip
self._set_label_to_pod_cache(labels, vm)
return vm
def create_virtual_machine(self, name, vn, ipaddress):
vm = VirtualMachine(name)
self._vnc_lib.virtual_machine_create(vm)
VirtualMachineKM.locate(vm.uuid)
vmi = VirtualMachineInterface(
parent_type='virtual-machine', fq_name=[name, '0'])
vmi.set_virtual_machine(vm)
vmi.set_virtual_network(vn)
self._vnc_lib.virtual_machine_interface_create(vmi)
VirtualMachineInterfaceKM.locate(vmi.uuid)
ip = InstanceIp(vm.name + '.0')
ip.set_virtual_machine_interface(vmi)
ip.set_virtual_network(vn)
ip.set_instance_ip_address(ipaddress)
self._vnc_lib.instance_ip_create(ip)
InstanceIpKM.locate(ip.uuid)
return vm, vmi, ip
def create_virtual_machine(self, name, vn, ipaddress):
vm = VirtualMachine(name)
self._vnc_lib.virtual_machine_create(vm)
VirtualMachineKM.locate(vm.uuid)
vmi = VirtualMachineInterface(
parent_type='virtual-machine', fq_name=[name, '0'])
vmi.set_virtual_machine(vm)
vmi.set_virtual_network(vn)
self._vnc_lib.virtual_machine_interface_create(vmi)
VirtualMachineInterfaceKM.locate(vmi.uuid)
ip = InstanceIp(vm.name + '.0')
ip.set_virtual_machine_interface(vmi)
ip.set_virtual_network(vn)
ip.set_instance_ip_address(ipaddress)
self._vnc_lib.instance_ip_create(ip)
InstanceIpKM.locate(ip.uuid)
return vm, vmi, ip
def create_virtual_machine(self, name, vn, ipaddress):
vm = VirtualMachine(name)
self._vnc_lib.virtual_machine_create(vm)
VirtualMachineKM.locate(vm.uuid)
vmi = VirtualMachineInterface(
parent_type='virtual-machine', fq_name=[name, '0'])
vmi.set_virtual_machine(vm)
vmi.set_virtual_network(vn)
if DBBaseKM.is_nested():
vmi.set_virtual_machine_interface_bindings(
KeyValuePairs([KeyValuePair('host_id', 'WHATEVER')]))
self._vnc_lib.virtual_machine_interface_create(vmi)
VirtualMachineInterfaceKM.locate(vmi.uuid)
ip = InstanceIp(vm.name + '.0')
ip.set_virtual_machine_interface(vmi)
ip.set_virtual_network(vn)
ip.set_instance_ip_address(ipaddress)
self._vnc_lib.instance_ip_create(ip)
InstanceIpKM.locate(ip.uuid)
return vm, vmi, ip
def create_virtual_machine(self, name, vn, ipaddress):
vm = VirtualMachine(name)
self._vnc_lib.virtual_machine_create(vm)
VirtualMachineKM.locate(vm.uuid)
vmi = VirtualMachineInterface(parent_type='virtual-machine',
fq_name=[name, '0'])
vmi.set_virtual_machine(vm)
vmi.set_virtual_network(vn)
if DBBaseKM.is_nested():
vmi.set_virtual_machine_interface_bindings(
KeyValuePairs([KeyValuePair('host_id', 'WHATEVER')]))
self._vnc_lib.virtual_machine_interface_create(vmi)
VirtualMachineInterfaceKM.locate(vmi.uuid)
ip = InstanceIp(vm.name + '.0')
ip.set_virtual_machine_interface(vmi)
ip.set_virtual_network(vn)
ip.set_instance_ip_address(ipaddress)
self._vnc_lib.instance_ip_create(ip)
InstanceIpKM.locate(ip.uuid)
return vm, vmi, ip
def _assert_virtual_machine(self, pod_uuid, cluster_project, proj_obj,
vn_obj_uuid):
vm = self._vnc_lib.virtual_machine_read(id=pod_uuid)
self.assertIsNotNone(vm)
vm = VirtualMachineKM.locate(vm.uuid)
self.assertIsNotNone(vm)
self.assertTrue(len(vm.virtual_machine_interfaces) > 0)
for vmi_id in list(vm.virtual_machine_interfaces):
vmi = self._vnc_lib.virtual_machine_interface_read(id=vmi_id)
self.assertIsNotNone(vmi)
self.assertEqual(vmi.parent_name, cluster_project)
self.assertEqual(vmi.parent_uuid, proj_obj.uuid)
vmi = VirtualMachineInterfaceKM.locate(vmi_id)
self.assertTrue(len(vmi.security_groups) > 1)
for sg_uuid in list(vmi.security_groups):
sg = self._vnc_lib.security_group_read(id=sg_uuid)
self.assertIsNotNone(sg)
self.assertTrue(len(vmi.instance_ips) == 1)
iip_uuid = list(vmi.instance_ips)[0]
iip = self._vnc_lib.instance_ip_read(id=iip_uuid)
self.assertIsNotNone(iip)
self._assert_pod_ip_is_from_vn_ipam(iip, vn_obj_uuid)
def _assert_virtual_machine(self, pod_uuid, cluster_project,
proj_obj, vn_obj_uuid):
vm = self._vnc_lib.virtual_machine_read(id=pod_uuid)
self.assertIsNotNone(vm)
vm = VirtualMachineKM.locate(vm.uuid)
self.assertIsNotNone(vm)
self.assertTrue(len(vm.virtual_machine_interfaces) > 0)
for vmi_id in list(vm.virtual_machine_interfaces):
vmi = self._vnc_lib.virtual_machine_interface_read(id=vmi_id)
self.assertIsNotNone(vmi)
self.assertEqual(vmi.parent_name, cluster_project)
self.assertEqual(vmi.parent_uuid, proj_obj.uuid)
vmi = VirtualMachineInterfaceKM.locate(vmi_id)
# self.assertTrue(len(vmi.security_groups) > 1)
# for sg_uuid in list(vmi.security_groups):
# sg = self._vnc_lib.security_group_read(id=sg_uuid)
# self.assertIsNotNone(sg)
self.assertTrue(len(vmi.instance_ips) == 1)
iip_uuid = list(vmi.instance_ips)[0]
iip = self._vnc_lib.instance_ip_read(id=iip_uuid)
self.assertIsNotNone(iip)
self._assert_pod_ip_is_from_vn_ipam(iip, vn_obj_uuid)
def vnc_pod_add(self, pod_id, pod_name, pod_namespace, pod_node, node_ip,
labels, vm_vmi):
vm = VirtualMachineKM.get(pod_id)
if vm:
vm.pod_namespace = pod_namespace
if not vm.virtual_router:
self._link_vm_to_node(vm, pod_node, node_ip)
self._set_label_to_pod_cache(labels, vm)
return vm
else:
self._check_pod_uuid_change(pod_id, pod_name)
vn_obj = self._get_network(pod_id, pod_name, pod_namespace)
if not vn_obj:
return
vm_obj = self._create_vm(pod_namespace, pod_id, pod_name, labels)
vmi_uuid = self._create_vmi(pod_name, pod_namespace, vm_obj, vn_obj,
vm_vmi)
vmi = VirtualMachineInterfaceKM.get(vmi_uuid)
if self._is_pod_nested() and vm_vmi:
# Pod is nested.
# Link the pod VMI to the VMI of the underlay VM.
self._vnc_lib.ref_update('virtual-machine-interface', vm_vmi.uuid,
'virtual-machine-interface', vmi_uuid,
None, 'ADD')
self._vnc_lib.ref_update('virtual-machine-interface', vmi_uuid,
'virtual-machine-interface', vm_vmi.uuid,
None, 'ADD')
# get host id for vm vmi
vr_uuid = None
for vr in VirtualRouterKM.values():
if vr.name == vm_vmi.host_id:
vr_uuid = vr.uuid
break
if not vr_uuid:
self._logger.error("No virtual-router object found for host: "
+ vm_vmi.host_id
+ ". Unable to add VM reference to a"
+ " valid virtual-router")
return
self._vnc_lib.ref_update('virtual-router', vr_uuid,
'virtual-machine', vm_obj.uuid, None,
'ADD')
self._create_iip(pod_name, pod_namespace, vn_obj, vmi)
if self._is_pod_network_isolated(pod_namespace):
self._create_cluster_service_fip(pod_name, pod_namespace, vmi_uuid)
if not self._is_pod_nested():
self._link_vm_to_node(vm_obj, pod_node, node_ip)
vm = VirtualMachineKM.locate(pod_id)
if vm:
vm.pod_namespace = pod_namespace
vm.pod_node = pod_node
vm.node_ip = node_ip
self._set_label_to_pod_cache(labels, vm)
return vm
def vnc_pod_add(self, pod_id, pod_name, pod_namespace, pod_node, node_ip,
labels, vm_vmi):
vm = VirtualMachineKM.get(pod_id)
if vm:
vm.pod_namespace = pod_namespace
if not vm.virtual_router:
self._link_vm_to_node(vm, pod_node, node_ip)
self._set_label_to_pod_cache(labels, vm)
# Update tags.
self._set_tags_on_pod_vmi(pod_id)
return vm
else:
self._check_pod_uuid_change(pod_id, pod_name)
vn_obj = self._get_network(pod_id, pod_name, pod_namespace)
if not vn_obj:
return
vm_obj = self._create_vm(pod_namespace, pod_id, pod_name, labels)
vmi_uuid = self._create_vmi(pod_name, pod_namespace, pod_id, vm_obj,
vn_obj, vm_vmi)
vmi = VirtualMachineInterfaceKM.get(vmi_uuid)
if self._is_pod_nested() and vm_vmi:
# Pod is nested.
# Link the pod VMI to the VMI of the underlay VM.
self._vnc_lib.ref_update('virtual-machine-interface', vm_vmi.uuid,
'virtual-machine-interface', vmi_uuid,
None, 'ADD')
self._vnc_lib.ref_update('virtual-machine-interface', vmi_uuid,
'virtual-machine-interface', vm_vmi.uuid,
None, 'ADD')
# get host id for vm vmi
vr_uuid = None
for vr in VirtualRouterKM.values():
if vr.name == vm_vmi.host_id:
vr_uuid = vr.uuid
break
if not vr_uuid:
# Unable to determine VRouter for the parent VM.
#
# HACK ALERT
#
# It is possible that this is a case of FQDN mismatch between
# the host name associated with the VM and the host name
# associated with the corresponding vrouter. So try to look for
# vrouter again with a non-FQDN name.
#
# This needs to be removed when provisioning can guarantee that
# FQDN will be uniform across all config objects.
#
if '.' in vm_vmi.host_id:
# Host name on VM is a FQNAME. Ignore domain name.
host_id_prefix = vm_vmi.host_id.split('.')[0]
for vr in VirtualRouterKM.values():
if vr.name == host_id_prefix:
vr_uuid = vr.uuid
break
if not vr_uuid:
self._logger.error(
"No virtual-router object found for host: " +
vm_vmi.host_id + ". Unable to add VM reference to a" +
" valid virtual-router")
return
self._vnc_lib.ref_update('virtual-router', vr_uuid,
'virtual-machine', vm_obj.uuid, None,
'ADD')
self._create_iip(pod_name, pod_namespace, vn_obj, vmi)
if not self._is_pod_nested():
self._link_vm_to_node(vm_obj, pod_node, node_ip)
vm = VirtualMachineKM.locate(pod_id)
if vm:
vm.pod_namespace = pod_namespace
vm.pod_node = pod_node
vm.node_ip = node_ip
self._set_label_to_pod_cache(labels, vm)
self._set_tags_on_pod_vmi(pod_id)
return vm
def vnc_pod_add(self, pod_id, pod_name, pod_namespace, pod_node, node_ip,
labels, vm_vmi):
vm = VirtualMachineKM.get(pod_id)
if vm:
vm.pod_namespace = pod_namespace
if not vm.virtual_router:
self._link_vm_to_node(vm, pod_node, node_ip)
self._set_label_to_pod_cache(labels, vm)
# Update tags.
self._set_tags_on_pod_vmi(pod_id)
return vm
vn_obj = self._get_default_network(pod_id, pod_name, pod_namespace)
if not vn_obj:
return
pod = PodKM.find_by_name_or_uuid(pod_id)
total_interface_count = len(pod.networks) + 1
# network_status: Dict of network name to vmi_uuid
network_status = {}
proj_fq_name = vnc_kube_config.cluster_project_fq_name(pod_namespace)
proj_obj = self._vnc_lib.project_read(fq_name=proj_fq_name)
vm_obj = self._create_vm(pod_namespace, pod_id, pod_name, labels,
proj_obj.uuid)
index = str(0) + "/" + str(total_interface_count)
default_network = {'network': 'default'}
vmi_uuid = self.vnc_pod_vmi_create(pod_id, pod_name, pod_namespace,
pod_node, node_ip, vm_obj, vn_obj,
proj_obj, vm_vmi, index,
default_network)
network_status['cluster-wide-default'] = vmi_uuid
for idx, network in enumerate(pod.networks, start=1):
net_namespace = pod_namespace
net_name = network['network']
if 'namespace' in network:
net_namespace = network['namespace']
vn_obj = self._get_user_defined_network(net_name, net_namespace)
index = str(idx) + "/" + str(total_interface_count)
vmi_uuid = self.vnc_pod_vmi_create(pod_id, pod_name, pod_namespace,
pod_node, node_ip, vm_obj,
vn_obj, proj_obj, vm_vmi, index,
network)
network_status[net_name] = vmi_uuid
if not self._is_pod_nested():
self._link_vm_to_node(vm_obj, pod_node, node_ip)
vm = VirtualMachineKM.locate(pod_id)
if vm:
vm.pod_namespace = pod_namespace
vm.pod_node = pod_node
vm.node_ip = node_ip
self._set_label_to_pod_cache(labels, vm)
self._set_tags_on_pod_vmi(pod_id)
# Update network-status in pod description
self._update_network_status(pod_name, pod_namespace,
network_status)
return vm
