Fix: Failing tests seem to be related to our specific Jenkins VM config.

[osm/vim-emu.git] / src / emuvim / test / unittests / test_sonata_dummy_gatekeeper.py

diff --git a/src/emuvim/test/unittests/test_sonata_dummy_gatekeeper.py b/src/emuvim/test/unittests/test_sonata_dummy_gatekeeper.py
index c96e1ba..9cdccac 100755 (executable)
--- a/src/emuvim/test/unittests/test_sonata_dummy_gatekeeper.py
+++ b/src/emuvim/test/unittests/test_sonata_dummy_gatekeeper.py
@@ -33,8 +33,9 @@ import os
 import unittest
 from emuvim.test.base import SimpleTestTopology
 from emuvim.api.sonata import SonataDummyGatekeeperEndpoint
-from emuvim.api.sonata.dummygatekeeper import initialize_GK
+from emuvim.api.sonata.dummygatekeeper import initialize_GK, parse_interface
 import mininet.clean
+from ipaddress import ip_network
 
 PACKAGE_PATH = "misc/sonata-demo-service.son"
 
@@ -44,40 +45,41 @@ class testSonataDummyGatekeeper(SimpleTestTopology):
 #    @unittest.skip("disabled")
     def test_GK_Api_start_service(self):
         # create network
-        self.createNet(nswitches=0, ndatacenter=2, nhosts=2, ndockers=0)
+        self.createNet(nswitches=0, ndatacenter=2, nhosts=2, ndockers=0, enable_learning=True)
         # setup links
         self.net.addLink(self.dc[0], self.h[0])
         self.net.addLink(self.dc[0], self.dc[1])
         self.net.addLink(self.h[1], self.dc[1])
         # connect dummy GK to data centers
-        sdkg1 = SonataDummyGatekeeperEndpoint("0.0.0.0", 5000)
+        sdkg1 = SonataDummyGatekeeperEndpoint("127.0.0.1", 55000)
         sdkg1.connectDatacenter(self.dc[0])
         sdkg1.connectDatacenter(self.dc[1])
         # run the dummy gatekeeper (in another thread, don't block)
         sdkg1.start()
+        time.sleep(3)
         # start Mininet network
         self.startNet()
-        time.sleep(1)
+        time.sleep(3)
 
         print "starting tests"
         # board package
         files = {"package": open(PACKAGE_PATH, "rb")}
-        r = requests.post("http://127.0.0.1:5000/packages", files=files)
+        r = requests.post("http://127.0.0.1:55000/packages", files=files)
         self.assertEqual(r.status_code, 201)
         self.assertTrue(json.loads(r.text).get("service_uuid") is not None)
 
         # instantiate service
         self.service_uuid = json.loads(r.text).get("service_uuid")
-        r2 = requests.post("http://127.0.0.1:5000/instantiations", data=json.dumps({"service_uuid": self.service_uuid}))
+        r2 = requests.post("http://127.0.0.1:55000/instantiations", data=json.dumps({"service_uuid": self.service_uuid}))
         self.assertEqual(r2.status_code, 201)
 
         # give the emulator some time to instantiate everything
         time.sleep(2)
 
         # check get request APIs
-        r3 = requests.get("http://127.0.0.1:5000/packages")
+        r3 = requests.get("http://127.0.0.1:55000/packages")
         self.assertEqual(len(json.loads(r3.text).get("service_uuid_list")), 1)
-        r4 = requests.get("http://127.0.0.1:5000/instantiations")
+        r4 = requests.get("http://127.0.0.1:55000/instantiations")
         self.assertEqual(len(json.loads(r4.text).get("service_instantiations_list")), 1)
 
         # check number of running nodes
@@ -87,14 +89,66 @@ class testSonataDummyGatekeeper(SimpleTestTopology):
         # check compute list result
         self.assertEqual(len(self.dc[0].listCompute()), 2)
         # check connectivity by using ping
+        ELAN_list=[]
+
+        # check E-Line connection, by checking the IP addresses
+        for link in self.net.deployed_elines:
+            vnf_src, intf_src, vnf_sap_docker_name = parse_interface(link['connection_points_reference'][0])
+            print vnf_src, intf_src
+            src = self.net.getNodeByName(vnf_src)
+            if not src:
+                continue
+            network_list = src.getNetworkStatus()
+            src_ip = [intf['ip'] for intf in network_list if intf['intf_name'] == intf_src][0]
+            src_mask = [intf['netmask'] for intf in network_list if intf['intf_name'] == intf_src][0]
+
+            vnf_dst,  intf_dst, vnf_sap_docker_name = parse_interface(link['connection_points_reference'][1])
+            dst = self.net.getNodeByName(vnf_dst)
+            if not dst:
+                continue
+            network_list = dst.getNetworkStatus()
+            dst_ip = [intf['ip'] for intf in network_list if intf['intf_name'] == intf_dst][0]
+            dst_mask = [intf['netmask'] for intf in network_list if intf['intf_name'] == intf_dst][0]
+
+            print "src = {0}:{1} ip={2} ".format(vnf_src, intf_src, src_ip, src_mask)
+            print "dst = {0}:{1} ip={2} ".format(vnf_dst, intf_dst, dst_ip, dst_mask)
+
+            # check if the E-Line IP's are in the same subnet
+            ret = ip_network(u'{0}'.format(src_ip, src_mask), strict=False)\
+                .compare_networks(ip_network(u'{0}'.format(dst_ip, dst_mask),strict=False))
+            self.assertTrue(ret == 0)
+
+
+        for vnf in self.dc[0].listCompute():
+            # check E LAN connection
+            network_list = vnf.getNetworkStatus()
+            mgmt_ip = [intf['ip'] for intf in network_list if intf['intf_name'] == 'mgmt']
+            self.assertTrue(len(mgmt_ip) > 0)
+            ip_address = mgmt_ip[0]
+            ELAN_list.append(ip_address)
+            print ip_address
+
+        # check ELAN connection by ping over the mgmt network (needs to be configured as ELAN in the test service)
         for vnf in self.dc[0].listCompute():
-            p = self.net.ping([self.h[0], vnf])
-            self.assertTrue(p <= 50.0)
+            network_list = vnf.getNetworkStatus()
+            mgmt_ip = [intf['ip'] for intf in network_list if intf['intf_name'] == 'mgmt']
+            self.assertTrue(len(mgmt_ip) > 0)
+            ip_address = mgmt_ip[0]
+            print ELAN_list
+            print ip_address
+            test_ip_list = list(ELAN_list)
+            test_ip_list.remove(ip_address)
+            for ip in test_ip_list:
+                # only take ip address, without netmask
+                p = self.net.ping([vnf],manualdestip=ip.split('/')[0])
+                print p
+                self.assertTrue(p <= 0.0)
+
         # stop Mininet network
         self.stopNet()
         initialize_GK()
 
-#    @unittest.skip("disabled")
+    #@unittest.skip("disabled")
     def test_GK_Api_stop_service(self):
         # create network
         self.createNet(ndatacenter=2, nhosts=2)
@@ -103,34 +157,35 @@ class testSonataDummyGatekeeper(SimpleTestTopology):
         self.net.addLink(self.dc[0], self.dc[1])
         self.net.addLink(self.h[1], self.dc[1])
         # connect dummy GK to data centers
-        sdkg1 = SonataDummyGatekeeperEndpoint("0.0.0.0", 5000)
+        sdkg1 = SonataDummyGatekeeperEndpoint("127.0.0.1", 55001)
         sdkg1.connectDatacenter(self.dc[0])
         sdkg1.connectDatacenter(self.dc[1])
         # run the dummy gatekeeper (in another thread, don't block)
         sdkg1.start()
+        time.sleep(3)
         # start Mininet network
         self.startNet()
-        time.sleep(1)
+        time.sleep(3)
 
         print "starting tests"
         # board package
         files = {"package": open(PACKAGE_PATH, "rb")}
-        r = requests.post("http://127.0.0.1:5000/packages", files=files)
+        r = requests.post("http://127.0.0.1:55001/packages", files=files)
         self.assertEqual(r.status_code, 201)
         self.assertTrue(json.loads(r.text).get("service_uuid") is not None)
 
         # instantiate service
         self.service_uuid = json.loads(r.text).get("service_uuid")
-        r2 = requests.post("http://127.0.0.1:5000/instantiations", data=json.dumps({"service_uuid": self.service_uuid}))
+        r2 = requests.post("http://127.0.0.1:55001/instantiations", data=json.dumps({"service_uuid": self.service_uuid}))
         self.assertEqual(r2.status_code, 201)
 
         # give the emulator some time to instantiate everything
         time.sleep(2)
 
         # check get request APIs
-        r3 = requests.get("http://127.0.0.1:5000/packages")
+        r3 = requests.get("http://127.0.0.1:55001/packages")
         self.assertEqual(len(json.loads(r3.text).get("service_uuid_list")), 1)
-        r4 = requests.get("http://127.0.0.1:5000/instantiations")
+        r4 = requests.get("http://127.0.0.1:55001/instantiations")
         self.assertEqual(len(json.loads(r4.text).get("service_instantiations_list")), 1)
 
         # check number of running nodes
@@ -143,55 +198,58 @@ class testSonataDummyGatekeeper(SimpleTestTopology):
         # stop the service
         service_instance_uuid = json.loads(r2.text).get("service_instance_uuid")
         self.assertTrue(service_instance_uuid is not None)
-        requests.delete("http://127.0.0.1:5000/instantiations", data=json.dumps({"service_uuid": self.service_uuid, "service_instance_uuid":service_instance_uuid}))
+        requests.delete("http://127.0.0.1:55001/instantiations", data=json.dumps({"service_uuid": self.service_uuid, "service_instance_uuid":service_instance_uuid}))
 
-        r5 = requests.get("http://127.0.0.1:5000/instantiations")
+        r5 = requests.get("http://127.0.0.1:55001/instantiations")
         self.assertTrue(len(json.loads(r5.text).get("service_instantiations_list")), 0)     # note that there was 1 instance before
 
         # stop Mininet network
         self.stopNet()
         initialize_GK()
 
+
+    #@unittest.skip("disabled")
     def test_GK_stress_service(self):
         # create network
         self.createNet(ndatacenter=2, nhosts=2)
         # connect dummy GK to data centers
-        sdkg1 = SonataDummyGatekeeperEndpoint("0.0.0.0", 5000)
+        sdkg1 = SonataDummyGatekeeperEndpoint("127.0.0.1", 55002)
         sdkg1.connectDatacenter(self.dc[0])
         sdkg1.connectDatacenter(self.dc[1])
         # run the dummy gatekeeper (in another thread, don't block)
         sdkg1.start()
+        time.sleep(3)
         # start Mininet network
         self.startNet()
-        time.sleep(1)
+        time.sleep(3)
 
         print "starting tests"
         # board package
         files = {"package": open("misc/sonata-stress-service.son", "rb")}
-        r = requests.post("http://127.0.0.1:5000/packages", files=files)
+        r = requests.post("http://127.0.0.1:55002/packages", files=files)
         self.assertEqual(r.status_code, 201)
         self.assertTrue(json.loads(r.text).get("service_uuid") is not None)
 
         # instantiate service
         self.service_uuid = json.loads(r.text).get("service_uuid")
-        r2 = requests.post("http://127.0.0.1:5000/instantiations", data=json.dumps({"service_uuid": self.service_uuid}))
+        r2 = requests.post("http://127.0.0.1:55002/instantiations", data=json.dumps({"service_uuid": self.service_uuid}))
         self.assertEqual(r2.status_code, 201)
 
         # give the emulator some time to instantiate everything
         time.sleep(2)
 
         # check get request APIs
-        r3 = requests.get("http://127.0.0.1:5000/packages")
+        r3 = requests.get("http://127.0.0.1:55002/packages")
         self.assertEqual(len(json.loads(r3.text).get("service_uuid_list")), 1)
-        r4 = requests.get("http://127.0.0.1:5000/instantiations")
+        r4 = requests.get("http://127.0.0.1:55002/instantiations")
         self.assertEqual(len(json.loads(r4.text).get("service_instantiations_list")), 1)
 
         # stop the service
         service_instance_uuid = json.loads(r2.text).get("service_instance_uuid")
         self.assertTrue(service_instance_uuid is not None)
-        requests.delete("http://127.0.0.1:5000/instantiations", data=json.dumps({"service_uuid": self.service_uuid, "service_instance_uuid":service_instance_uuid}))
+        requests.delete("http://127.0.0.1:55002/instantiations", data=json.dumps({"service_uuid": self.service_uuid, "service_instance_uuid":service_instance_uuid}))
 
-        r5 = requests.get("http://127.0.0.1:5000/instantiations")
+        r5 = requests.get("http://127.0.0.1:55002/instantiations")
         self.assertTrue(len(json.loads(r5.text).get("service_instantiations_list")), 0)     # note that there was 1 instance before
 
         # stop Mininet network