--- /dev/null
+import sys\r
+import os\r
+import time\r
+import json\r
+import re\r
+import danm_utils\r
+from robot.api import logger\r
+from robot.libraries.BuiltIn import BuiltIn\r
+from netaddr import IPAddress\r
+\r
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', '../libraries/common'))\r
+import common_utils # noqa\r
+from execute_command import execute_command # noqa\r
+from decorators_for_robot_functionalities import * # noqa\r
+from test_constants import * # noqa\r
+\r
+\r
+execute = BuiltIn().get_library_instance('execute_command')\r
+stack_infos = BuiltIn().get_library_instance('stack_infos')\r
+flannel_pool = {'start': '10.244.0.1', 'end': '10.244.255.254'}\r
+static_ips = ["10.5.1.11", "10.5.1.19", "10.5.1.20", "10.5.255.254", ]\r
+infra_int_if = stack_infos.get_infra_int_if()\r
+infra_ext_if = stack_infos.get_infra_ext_if()\r
+infra_storage_if = stack_infos.get_infra_storage_if()\r
+\r
+\r
+def tc_003_clusternetwork_pod_check():\r
+ """\r
+ danmnet_pods1: pods attached to d_test-net2 with static ips\r
+ danmnet_pods2: pods attached to d_test-net2 with dynamic ips\r
+ danmnet_pods3: pods attached to d_test-net2 with the same static ips as danmnet-pods1\r
+ danmnet_pods4: pods attached to ks_test-net2 with dynamic ips (kube-system namespace)\r
+ danmnet_pods5: pod attached to d_test-net2 with static ip, ip is not in CIDR\r
+ danmnet_pods6: pods attached to d_test-net1 with dynamic ips (no CIDR/alloc pool is defined in test-net1 )\r
+ danmnet_pods7: pods attached to d_test-net24(flannel) and d_test-net7(ipvlan) networks with dynamic ip\r
+ danmnet_pods8: pods attached to d_test-net24(flannel) with dynamic ip and service defined\r
+ danmnet_pods9: pods attached to d_test-net24(flannel) with static ip(ignored)\r
+ danmnet_pods10: pods attached to d_test-net2 with none ip\r
+ danmnet_pods11: pod attached to d_test-net30 with static ip, d_test-net8 with none ip, none existing\r
+ danmnet(error)\r
+ danmnet_pods12: pod attached to d_test-net30 with static ip, d_test-net8 with dynamic ip, d_test-net25 with\r
+ none ip\r
+ danmnet_pods13: pod attached to d_test-net8 with static ip, d_test-net24(flannel) with dynamic ip, none existing\r
+ danmnet(error)\r
+ danmnet_pods14: pod attached to d_test-net25 with static ip, d_test-net24(flannel) with dynamic ip\r
+\r
+ danmnet_pods1: pods attached to cnet-pod1 with static ips\r
+ danmnet_pods2: pods attached to cnet-pod1 with dynamic ips\r
+ danmnet_pods3: pods attached to cnet-pod1 with the same static ips as danmnet-pods1\r
+ danmnet_pods4: pods attached to ks_test-net2 with dynamic ips (kube-system namespace)\r
+ danmnet_pods5: pod attached to cnet-pod1 with static ip, ip is not in CIDR\r
+ danmnet_pods6: pods attached to d_test-net1 with dynamic ips (no CIDR/alloc pool is defined in test-net1 )\r
+ danmnet_pods7: pods attached to d_test-net24(flannel) and d_test-net7(ipvlan) networks with dynamic ip\r
+ danmnet_pods8: pods attached to d_test-net24(flannel) with dynamic ip and service defined\r
+ danmnet_pods9: pods attached to d_test-net24(flannel) with static ip(ignored)\r
+ danmnet_pods10: pods attached to cnet-pod1 with none ip\r
+ danmnet_pods11: pod attached to d_test-net30 with static ip, d_test-net8 with none ip,\r
+ none existing danmnet(error)\r
+ danmnet_pods12: pod attached to d_test-net30 with static ip, d_test-net8 with dynamic ip,\r
+ d_test-net25 with none ip\r
+ danmnet_pods13: pod attached to d_test-net8 with static ip, d_test-net24(flannel) with dynamic ip,\r
+ none existing danmnet(error)\r
+ danmnet_pods14: pod attached to d_test-net25 with static ip, d_test-net24(flannel) with dynamic ip\r
+\r
+\r
+ """\r
+ steps = ['step1', 'step2', 'step3', 'step5', 'step7', 'step8', 'step9', 'step10', 'step11', 'step12', 'step13',\r
+ 'step14', 'tc_003_clusternetwork_pod_check.Teardown']\r
+\r
+ BuiltIn().run_keyword("tc_003_clusternetwork_pod_check.Setup")\r
+ common_utils.keyword_runner(steps)\r
+\r
+\r
+def Setup():\r
+ # execute.execute_unix_command("kubectl create -f /tmp/clusternetwork-test/templates/cnet_attach.yaml")\r
+ network_attach_test = common_utils.get_helm_chart_content("default/network-attach-test")\r
+ compare_test_data(network_attach_test, network_attach_properties)\r
+ replace_ifaces_in_fetched_chart_templates("/tmp/network-attach-test/templates/*")\r
+ danm_utils.create_resources_from_fetched_chart_templates("/tmp/network-attach-test/templates")\r
+\r
+ install_chart(danmnet_pods1)\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods1,\r
+ expected_result=danmnet_pods1['obj_count'],\r
+ filter=r'(Running)\s*[0]',\r
+ timeout=90)\r
+ install_chart(danmnet_pods2)\r
+ install_chart(danmnet_pods3)\r
+ # install_chart(danmnet_pods4)\r
+ install_chart(danmnet_pods5)\r
+ install_chart(danmnet_pods6)\r
+ install_chart(danmnet_pods7)\r
+ install_chart(danmnet_pods8)\r
+ install_chart(danmnet_pods9)\r
+ install_chart(danmnet_pods10)\r
+\r
+\r
+def Teardown():\r
+ common_utils.helm_delete("danmnet-pods12")\r
+ common_utils.helm_delete("danmnet-pods14")\r
+ danm_utils.delete_resources_by_manifest_path("/tmp/network-attach-test/templates/")\r
+\r
+\r
+def step1():\r
+ # Install danmnet_pods1: all of the pods should be in Running state, check static ips, mac address\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods1,\r
+ expected_result=danmnet_pods1['obj_count'],\r
+ filter=r'(Running)\s*[0]',\r
+ timeout=90,\r
+ delay=10)\r
+ pod_list = get_pod_list(danmnet_pods1)\r
+ danmnet_pods1['ip_list'] = get_pod_ips(pod_list)\r
+ if set(danmnet_pods1['ip_list']) != set(static_ips):\r
+ raise Exception("Static ip allocation for danmnet-pods1 was not successful, assigned ips!")\r
+ logger.info("Static ip allocation for danmnet-pods1 was successful")\r
+ check_mac_address(pod_list, 'cnet_pod1')\r
+\r
+\r
+def step2():\r
+ # Install danmnet_pods2: ips already used from allocation pool -> 3 pods in containercreating state, check remaining\r
+ # assigned ips in allocation pool\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods2,\r
+ expected_result=danmnet_pods2['obj_count'],\r
+ filter=r'(ContainerCreating)\s*[0]',\r
+ timeout=90)\r
+ pod_list = get_pod_list(danmnet_pods2)\r
+ alloc_pool = get_alloc_pool('cnet_pod1', network_attach_properties, 'clusternetwork')\r
+ danmnet_pods2['ip_list'] = get_pod_ips(pod_list)\r
+ check_dynamic_ips(alloc_pool, danmnet_pods2['ip_list'])\r
+\r
+\r
+def step3():\r
+ # Danmnet_pods3 pods are not running because static ips are already allocated\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods3,\r
+ expected_result=danmnet_pods3['obj_count'],\r
+ filter=r'(ContainerCreating)\s*[0]',\r
+ timeout=90)\r
+ # Delete danmnet_pods1, danmnet_pods2\r
+ common_utils.helm_delete("danmnet-pods2")\r
+ common_utils.check_kubernetes_object(kube_object=danmnet_pods2,\r
+ tester_function=common_utils.test_kubernetes_object_not_available,\r
+ timeout=90)\r
+ common_utils.helm_delete("danmnet-pods1")\r
+\r
+\r
+def step5():\r
+ # Check danmnet_pods1, danmnet_pods2 are purged, ips are reallocated for danmnet_pods3\r
+\r
+ common_utils.check_kubernetes_object(kube_object=danmnet_pods1,\r
+ tester_function=common_utils.test_kubernetes_object_not_available,\r
+ timeout=90)\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods3,\r
+ expected_result=danmnet_pods3['obj_count'],\r
+ filter=r'(Running)\s*[0]',\r
+ timeout=60)\r
+ pod_list = get_pod_list(danmnet_pods3)\r
+ assigned_ips = get_pod_ips(pod_list, skip_restarts=True)\r
+ if set(assigned_ips) != set(static_ips):\r
+ raise Exception("Static ip allocation for danmnet-pods3 was not successful!")\r
+ logger.info("Static ip allocation for danmnet-pods3 was successful")\r
+ check_static_routes(pod_list, 'cnet_pod1')\r
+\r
+ actual_pod = list(pod_list)[0]\r
+ check_connectivity(pod_list, actual_pod, static_ips)\r
+ actual_pod = list(pod_list)[3]\r
+ check_connectivity(pod_list, actual_pod, static_ips)\r
+\r
+\r
+def step6():\r
+ common_utils.check_kubernetes_object(kube_object=danmnet_pods4,\r
+ tester_function=common_utils.test_kubernetes_object_not_available,\r
+ timeout=90)\r
+ check_danmnet_endpoints(danmnet_pods4, 'test-net2', danmnet_pods4['ip_list'])\r
+\r
+\r
+def step7():\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods5,\r
+ expected_result=danmnet_pods5['obj_count'],\r
+ filter=r'(ContainerCreating)\s*[0]',\r
+ timeout=90)\r
+\r
+\r
+def step8():\r
+ # Dynamic ip allocation fails if no CIDR/allocation pool defined\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods6,\r
+ expected_result=danmnet_pods6['obj_count'],\r
+ filter=r'(ContainerCreating)\s*[0]',\r
+ timeout=90)\r
+\r
+\r
+def step9():\r
+ # multiple interfaces, check flannel and ipvlan ip allocation\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods7,\r
+ expected_result=danmnet_pods7['obj_count'],\r
+ filter=r'(Running)\s*[0]',\r
+ timeout=90)\r
+ pod_list = get_pod_list(danmnet_pods7)\r
+ assigned_ips = get_pod_ips(pod_list)\r
+ check_dynamic_ips(flannel_pool, assigned_ips)\r
+\r
+ alloc_pool = get_alloc_pool('cnet_pod3', network_attach_properties, 'clusternetwork')\r
+ assigned_ips = get_pod_ips(pod_list, if_name='')\r
+ check_dynamic_ips(alloc_pool, assigned_ips)\r
+\r
+\r
+def step10():\r
+ # Check service is reachable with flannel\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods8,\r
+ expected_result=danmnet_pods8['obj_count'],\r
+ filter=r'(Running)\s*[0]',\r
+ timeout=90)\r
+ command = "curl danmnet-pods8-1.default.svc.rec.io:4242"\r
+ res = execute.execute_unix_command_as_root(command)\r
+ if "OK" not in res:\r
+ raise Exception("NOK: danmnet-pods8-1 service is not reachable")\r
+ logger.info("OK: danmnet-pods8-1 service is reachable")\r
+ pod_list = get_pod_list(danmnet_pods8)\r
+ assigned_ips = get_pod_ips(pod_list)\r
+ check_dynamic_ips(flannel_pool, assigned_ips)\r
+\r
+\r
+def step11():\r
+ # Static ip allocation is ignored with flannel\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods9,\r
+ expected_result=danmnet_pods9['obj_count'],\r
+ filter=r'(Running)\s*[0]',\r
+ timeout=90)\r
+\r
+\r
+def step12():\r
+ # None ip, pod is restarting\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods10,\r
+ expected_result=danmnet_pods10['obj_count'],\r
+ filter=r'(ContainerCreating)\s*[0]',\r
+ timeout=90)\r
+ common_utils.helm_delete("danmnet-pods3")\r
+ common_utils.helm_delete("danmnet-pods4")\r
+ common_utils.helm_delete("danmnet-pods5")\r
+ common_utils.helm_delete("danmnet-pods6")\r
+ common_utils.helm_delete("danmnet-pods7")\r
+ common_utils.helm_delete("danmnet-pods8")\r
+ common_utils.helm_delete("danmnet-pods9")\r
+ common_utils.helm_delete("danmnet-pods10")\r
+ common_utils.check_kubernetes_object(kube_object=danmnet_pods_all,\r
+ tester_function=common_utils.test_kubernetes_object_not_available,\r
+ timeout=20)\r
+ check_dep_count(danmnet_pods1["namespace"], exp_count=0)\r
+\r
+\r
+@pabot_lock("pv_test_ip")\r
+@pabot_lock("flannel_ip")\r
+@pabot_lock("flannel_ip2")\r
+def step13():\r
+ # danmnet_pods11, danmnet_pods13 has invalid networks attached hance the pod creation will fail,\r
+ # checking if danmnet endpoints, ips are cleared after several unsuccessful pod creations\r
+ alloc_before_cnet_pod5 = get_alloc_value('cnet_pod5', network_attach_properties, 'clusternetwork')\r
+ alloc_before_cnet_pod6 = get_alloc_value('cnet_pod6', network_attach_properties, 'clusternetwork')\r
+ common_utils.get_helm_chart_content('default/' + danmnet_pods11['obj_name'])\r
+ execute.execute_unix_command("sed -i 's/{{ .Values.registry_url }}/" + reg + "/g' " + "/tmp/" +\r
+ danmnet_pods11['obj_name'] + "/templates/" + danmnet_pods11['obj_name'] + ".yaml")\r
+ common_utils.get_helm_chart_content('default/' + danmnet_pods13['obj_name'])\r
+ execute.execute_unix_command("sed -i 's/{{ .Values.registry_url }}/" + reg + "/g' " + "/tmp/" +\r
+ danmnet_pods13['obj_name'] + "/templates/" + danmnet_pods13['obj_name'] + ".yaml")\r
+ command = "ls -rt /var/lib/cni/networks/cbr0/ | wc -l"\r
+ ip_count_before = execute.execute_unix_command_as_root(command)\r
+ command = "ls -rt /var/lib/cni/networks/cbr0/"\r
+ cbr0_content1 = execute.execute_unix_command_as_root(command)\r
+\r
+ for _ in range(0, 10):\r
+ # danmnet_pods11 creation fails\r
+ command = "kubectl create -f /tmp/" + danmnet_pods11['obj_name'] + "/templates"\r
+ execute.execute_unix_command_as_root(command)\r
+\r
+ # danmnet_pods13 creation fails\r
+ command = "kubectl create -f /tmp/" + danmnet_pods13['obj_name'] + "/templates"\r
+ execute.execute_unix_command_as_root(command)\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods11,\r
+ expected_result=danmnet_pods11['obj_count'],\r
+ filter=r'(ContainerCreating)\s*[0]',\r
+ timeout=40)\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods13,\r
+ expected_result=danmnet_pods13['obj_count'],\r
+ filter=r'(ContainerCreating)\s*[0]',\r
+ timeout=40)\r
+ command = "kubectl delete -f /tmp/" + danmnet_pods11['obj_name'] + "/templates"\r
+ execute.execute_unix_command_as_root(command)\r
+ command = "kubectl delete -f /tmp/" + danmnet_pods13['obj_name'] + "/templates"\r
+ execute.execute_unix_command_as_root(command)\r
+ common_utils.check_kubernetes_object(kube_object=danmnet_pods11,\r
+ tester_function=common_utils.test_kubernetes_object_not_available,\r
+ timeout=40)\r
+ common_utils.check_kubernetes_object(kube_object=danmnet_pods13,\r
+ tester_function=common_utils.test_kubernetes_object_not_available,\r
+ timeout=40)\r
+ check_danm_count(ip_count_before, cbr0_content1, 0)\r
+ logger.info("All flannel ips are cleared")\r
+ alloc_after_cnet_pod5 = get_alloc_value('cnet_pod5', network_attach_properties, 'clusternetwork')\r
+ alloc_after_cnet_pod6 = get_alloc_value('cnet_pod6', network_attach_properties, 'clusternetwork')\r
+ if alloc_after_cnet_pod6 != alloc_before_cnet_pod6:\r
+ raise Exception("allocation value in cnet-pod6 is not as expected")\r
+ if alloc_after_cnet_pod5 != alloc_before_cnet_pod5:\r
+ raise Exception("allocation value in cnet-pod5 is not as expected")\r
+ check_dep_count('default', exp_count=0)\r
+\r
+\r
+def step14():\r
+ # Static ip, dynamic ip allocation and none ip in the same pod\r
+ # Check if the same ips can be allocated, which were failing in step 13\r
+ install_chart(danmnet_pods12)\r
+ install_chart(danmnet_pods14)\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods12,\r
+ expected_result=danmnet_pods12['obj_count'],\r
+ filter=r'(Running)\s*[0]',\r
+ timeout=90)\r
+ pod_list = get_pod_list(danmnet_pods12)\r
+ alloc_pool = get_alloc_pool('cnet_pod6', network_attach_properties, 'clusternetwork')\r
+ danmnet_pods12['ip_list'] = get_pod_ips(pod_list, if_name='eth1')\r
+ check_dynamic_ips(alloc_pool, danmnet_pods12['ip_list'])\r
+ danmnet_pods12['ip_list'] = get_pod_ips(pod_list, if_name='eth0')\r
+ if IPAddress(danmnet_pods12['ip_list'][0]) != IPAddress('10.10.0.250'):\r
+ raise Exception("static ip in pod danmnet-pods12 is not as expected")\r
+\r
+ common_utils.test_kubernetes_object_quality(kube_object=danmnet_pods14,\r
+ expected_result=danmnet_pods14['obj_count'],\r
+ filter=r'(Running)\s*[0]',\r
+ timeout=90)\r
+ pod_list = get_pod_list(danmnet_pods14)\r
+ danmnet_pods14['ip_list'] = get_pod_ips(pod_list, if_name='eth2')\r
+ if IPAddress(danmnet_pods14['ip_list'][0]) != IPAddress('10.10.0.254'):\r
+ raise Exception("static ip in pod danmnet-pods14 is not as expected")\r
+ common_utils.helm_delete("danmnet-pods12")\r
+ common_utils.helm_delete("danmnet-pods14")\r
+ common_utils.check_kubernetes_object(kube_object=danmnet_pods14,\r
+ tester_function=common_utils.test_kubernetes_object_not_available,\r
+ timeout=20)\r
+ check_dep_count(danmnet_pods12["namespace"], exp_count=0)\r
+\r
+\r
+@robot_log\r
+def check_danm_count(ip_count_before_parameter, cbr0_content1_parameter, tries):\r
+ command = "ls -rt /var/lib/cni/networks/cbr0/"\r
+ cbr0_content2 = execute.execute_unix_command_as_root(command)\r
+ if tries == 3:\r
+ diff = list(set(cbr0_content1_parameter) - set(cbr0_content2))\r
+ logger.info("Additional IPs after step: " + diff)\r
+ for ip in diff:\r
+ command = "cat /var/lib/cni/networks/cbr0/" + ip + " | grep -v eth"\r
+ cid = execute.execute_unix_command(command)\r
+ command = "docker ps -a --no-trunc | grep " + cid\r
+ docker_ps = execute.execute_unix_command(command)\r
+ logger.info("Additional ip belongs to the following container: " + docker_ps)\r
+ raise Exception("Flannel ips are not cleared after pod deletion")\r
+ else:\r
+ tries = tries + 1\r
+ command = "ls -rt /var/lib/cni/networks/cbr0/ | wc -l"\r
+ ip_count_after = execute.execute_unix_command_as_root(command)\r
+ ip_count_before = ip_count_before_parameter\r
+ cbr0_content1 = cbr0_content1_parameter\r
+ if ip_count_before != ip_count_after:\r
+ logger.info(cbr0_content1)\r
+ logger.info(cbr0_content2)\r
+ time.sleep(30)\r
+ check_danm_count(ip_count_before, cbr0_content1, tries)\r
+\r
+\r
+def install_chart(kube_object):\r
+ common_utils.helm_install(chart_name="default/" + kube_object['obj_name'], release_name=kube_object['obj_name'])\r
+\r
+\r
+@robot_log\r
+def get_pod_ips(pod_list, skip_restarts=False, if_name='eth0'):\r
+ assigned_ips = []\r
+ for key in pod_list:\r
+ if (pod_list[key]['status'] == 'Running') and ((pod_list[key]['restarts'] == '0') or skip_restarts):\r
+ logger.info(pod_list[key]['namespace'])\r
+ if if_name != '':\r
+ command = "kubectl exec " + key + " -n " + pod_list[key]['namespace'] + " ip a | grep " + if_name + \\r
+ " | grep inet | awk '{print $2}' | awk -F \"/\" '{print $1}' "\r
+ else:\r
+ command = "kubectl exec " + key + " -n " + pod_list[key]['namespace'] + \\r
+ " -- ip -o a | grep -vE '(: lo|: eth0)' | grep inet | awk '{print $4}' | " \\r
+ "awk -F \"/\" '{print $1}'"\r
+ assigned_ips.append(execute.execute_unix_command_as_root(command))\r
+ return assigned_ips\r
+\r
+\r
+@robot_log\r
+def get_alloc_pool(network, dictionary, resource_type):\r
+ alloc_pool = {}\r
+ command = "kubectl get " + resource_type + " " + dictionary[network]['name'] + " -o yaml " + \\r
+ " | grep allocation_pool -A 2 | grep start | awk {'print$2'}"\r
+ alloc_pool['start'] = execute.execute_unix_command_as_root(command)\r
+ command = "kubectl get " + resource_type + " " + dictionary[network]['name'] + " -o yaml " + \\r
+ " | grep allocation_pool -A 2 | grep end | awk {'print$2'}"\r
+ alloc_pool['end'] = execute.execute_unix_command_as_root(command)\r
+ return alloc_pool\r
+\r
+\r
+@robot_log\r
+def get_pod_list(kube_object):\r
+ pod_list = {}\r
+ command = "kubectl get pod --all-namespaces | grep -w " + kube_object[\r
+ 'obj_name'] + " | awk '{print $1 \" \" $2 \" \" $4 \" \" $5}'"\r
+ for line in execute.execute_unix_command_as_root(command).split('\r\n'):\r
+ pod_list[line.split(' ')[1]] = {'namespace': line.split(' ')[0], 'status': line.split(' ')[2],\r
+ 'restarts': line.split(' ')[3]}\r
+ return pod_list\r
+\r
+\r
+@robot_log\r
+def check_dynamic_ips(alloc_pool, assigned_ips):\r
+ for ip in assigned_ips:\r
+ if (IPAddress(alloc_pool['start']) > IPAddress(ip)) or (IPAddress(ip) > IPAddress(alloc_pool['end'])):\r
+ raise Exception("Dynamic ip is not in allocation pool")\r
+ logger.info("All dynamic ips are from the allocation pool.")\r
+ if len(list(set(assigned_ips))) != len(assigned_ips):\r
+ raise Exception("duplicated IPs assigned")\r
+ logger.info("All allocated IPs are unique")\r
+\r
+\r
+@robot_log\r
+def check_static_routes(pod_list, danmnet):\r
+ for pod in pod_list:\r
+ if (pod_list[pod]['status'] == 'Running') and (pod_list[pod]['restarts'] == '0'):\r
+ command = "kubectl exec " + pod + " -n " + pod_list[pod]['namespace'] + " route | grep " + \\r
+ network_attach_properties[danmnet]['routes'].split('/')[0] + " | grep " + \\r
+ network_attach_properties[danmnet]['routes'].split(' ')[1] + " | wc -l"\r
+ res = execute.execute_unix_command_as_root(command)\r
+ if res != '1':\r
+ raise Exception("static route in pod " + pod + " does not match with route defined in " + danmnet)\r
+ logger.info("Static route in pod " + pod + " is as it should be.")\r
+\r
+\r
+@robot_log\r
+def check_mac_address(pod_list, network):\r
+ command = "ip a | grep -wA 1 " + network_attach_properties[network]['host_if'] + " | grep ether | awk '{print $2}'"\r
+ host_mac = execute.execute_unix_command_as_root(command)\r
+ for pod in pod_list:\r
+ if (pod_list[pod]['status'] == 'Running') and (pod_list[pod]['restarts'] == '0'):\r
+ command = "kubectl exec " + pod + " -n " + pod_list[pod]['namespace'] + " ip a | grep -A 1 eth0 | " \\r
+ "grep link | awk '{print $2}'"\r
+ pod_mac = execute.execute_unix_command_as_root(command)\r
+ if host_mac != pod_mac:\r
+ raise Exception("Wrong Mac address in pod " + pod)\r
+ logger.info("Correct mac address in pod " + pod)\r
+\r
+\r
+@robot_log\r
+def check_danmnet_endpoints(kube_object, network, assigned_ips):\r
+ for ip in assigned_ips:\r
+ command = "kubectl get danmep -n " + kube_object['namespace'] + " -o yaml | grep -B 10 " + \\r
+ network_attach_properties[network]['name'] + " | grep " + ip + " | wc -l"\r
+ res = execute.execute_unix_command_as_root(command)\r
+ if res != '0':\r
+ raise Exception("Endpoint with ip " + ip + " still exists.")\r
+ logger.info("The necessary endpoints are cleared")\r
+\r
+\r
+@robot_log\r
+def check_connectivity(pod_list, pod, ip_list):\r
+ for ip in ip_list:\r
+ command = "kubectl exec " + pod + " -n " + pod_list[pod]['namespace'] + " -- sh -c \"ping -c 1 " + ip + "\""\r
+ stdout = execute.execute_unix_command_as_root(command)\r
+ if '0% packet loss' not in stdout:\r
+ raise Exception("pod " + pod + " cannot reach ip " + ip)\r
+ logger.info("pod " + pod + " can reach ip " + ip)\r
+\r
+\r
+@robot_log\r
+def check_dep_count(namespace, exp_count):\r
+ tries = 0\r
+ danm_eps = get_deps(namespace)\r
+ test_pod_name_pattern = r'^danmnet-pods'\r
+ danmnet_test_deps = [dep for dep in danm_eps if is_dep_belongs_to_pod(dep, test_pod_name_pattern)]\r
+ while (tries < 5) and (len(danmnet_test_deps) != exp_count):\r
+ time.sleep(20)\r
+ tries += 1\r
+ danm_eps = get_deps(namespace)\r
+ danmnet_test_deps = [dep for dep in danm_eps if is_dep_belongs_to_pod(dep, test_pod_name_pattern)]\r
+\r
+ if len(danmnet_test_deps) != exp_count:\r
+ raise Exception("Danm endpoint count is not as expected! Got: " + str(len(danmnet_test_deps)) + ", expected: " +\r
+ str(exp_count))\r
+ logger.info("Danm endpoint count is as expected.")\r
+\r
+\r
+@robot_log\r
+def get_deps(namespace):\r
+ command = "kubectl get dep -n {} -o json".format(namespace)\r
+ deps_text = execute.execute_unix_command_as_root(command)\r
+ return json.loads(deps_text).get("items")\r
+\r
+\r
+@robot_log\r
+def is_dep_belongs_to_pod(dep, pod_pattern):\r
+ pod_name = dep["spec"]["Pod"]\r
+ return bool(re.search(pod_pattern, pod_name))\r
+\r
+\r
+@robot_log\r
+def get_alloc_value(network, dictionary, resource_type):\r
+ command = "kubectl get " + resource_type + " " + dictionary[network]['name'] + " -o yaml | grep -w alloc | " \\r
+ "awk '{print $2}'"\r
+ alloc = execute.execute_unix_command_as_root(command)\r
+ return alloc\r
+\r
+\r
+@robot_log\r
+def replace_ifaces_in_fetched_chart_templates(path):\r
+ execute.execute_unix_command("sed -i 's/{{ .Values.infra_int_if }}/" + infra_int_if + "/g' " + path)\r
+ execute.execute_unix_command("sed -i 's/{{ .Values.infra_ext_if }}/" + infra_ext_if + "/g' " + path)\r
+ execute.execute_unix_command("sed -i 's/{{ .Values.infra_storage_if }}/" + infra_storage_if + "/g' " + path)\r
+\r
+\r
+@robot_log\r
+def compare_test_data(list_to_compare, dict_to_compare):\r
+ for danmnet in list_to_compare:\r
+ if danmnet not in dict_to_compare:\r
+ logger.warn(danmnet + " is not present in test constants: {}".format(dict_to_compare))\r
+ for key in dict_to_compare:\r
+ if key not in list_to_compare:\r
+ logger.warn(key + " is not present in {} chart".format(list_to_compare))\r
+\r
+\r
+@robot_log\r
+def delete_all_resources(resource_type):\r
+ execute.execute_unix_command("kubectl delete " + resource_type + " --all")\r
Code Review / ta / cloudtaf.git / blobdiff