test/testbeds/netns/integration.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 import getpass
   5 from nepi.core.design import ExperimentDescription, FactoriesProvider
   6 from nepi.core.execute import ExperimentController
   7 from nepi.util import proxy
   8 import os
   9 import shutil
  10 import tempfile
  11 import test_util
  12 import time
  13 import unittest
  14
  15 class NetnsIntegrationTestCase(unittest.TestCase):
  16     def setUp(self):
  17         self.root_dir = tempfile.mkdtemp()
  18
  19     @test_util.skipUnless(os.getuid() == 0, "Test requires root privileges")
  20     def test_local_if(self):
  21         exp_desc = ExperimentDescription()
  22         testbed_version = "01"
  23         testbed_id = "netns"
  24         user = getpass.getuser()
  25         netns_provider = FactoriesProvider(testbed_id, testbed_version)
  26         netns_desc = exp_desc.add_testbed_description(netns_provider)
  27         netns_desc.set_attribute_value("homeDirectory", self.root_dir)
  28         #netns_desc.set_attribute_value("enableDebug", True)
  29         node1 = netns_desc.create("Node")
  30         node2 = netns_desc.create("Node")
  31         iface1 = netns_desc.create("NodeInterface")
  32         iface1.set_attribute_value("up", True)
  33         node1.connector("devs").connect(iface1.connector("node"))
  34         ip1 = iface1.add_address()
  35         ip1.set_attribute_value("Address", "10.0.0.1")
  36         iface2 = netns_desc.create("NodeInterface")
  37         iface2.set_attribute_value("up", True)
  38         node2.connector("devs").connect(iface2.connector("node"))
  39         ip2 = iface2.add_address()
  40         ip2.set_attribute_value("Address", "10.0.0.2")
  41         switch = netns_desc.create("Switch")
  42         switch.set_attribute_value("up", True)
  43         iface1.connector("switch").connect(switch.connector("devs"))
  44         iface2.connector("switch").connect(switch.connector("devs"))
  45         app = netns_desc.create("Application")
  46         app.set_attribute_value("command", "ping -qc1 10.0.0.2")
  47         app.set_attribute_value("user", user)
  48         app.connector("node").connect(node1.connector("apps"))
  49         app.enable_trace("stdout")
  50         xml = exp_desc.to_xml()
  51
  52         controller = ExperimentController(xml)
  53         controller.start()
  54         while not controller.is_finished(app.guid):
  55             time.sleep(0.5)
  56         ping_result = controller.trace(netns_desc.guid, app.guid, "stdout")
  57         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
  58
  59 --- 10.0.0.2 ping statistics ---
  60 1 packets transmitted, 1 received, 0% packet loss, time 0ms
  61 """
  62         self.assertTrue(ping_result.startswith(comp_result))
  63         controller.stop()
  64         controller.shutdown()
  65
  66     @test_util.skipUnless(os.getuid() == 0, "Test requires root privileges")
  67     def test_all_daemonized_if(self):
  68         exp_desc = ExperimentDescription()
  69         testbed_version = "01"
  70         testbed_id = "netns"
  71         user = getpass.getuser()
  72         netns_provider = FactoriesProvider(testbed_id, testbed_version)
  73         netns_desc = exp_desc.add_testbed_description(netns_provider)
  74         netns_desc.set_attribute_value("homeDirectory", self.root_dir)
  75         #netns_desc.set_attribute_value("enableDebug", True)
  76         node1 = netns_desc.create("Node")
  77         node2 = netns_desc.create("Node")
  78         iface1 = netns_desc.create("NodeInterface")
  79         iface1.set_attribute_value("up", True)
  80         node1.connector("devs").connect(iface1.connector("node"))
  81         ip1 = iface1.add_address()
  82         ip1.set_attribute_value("Address", "10.0.0.1")
  83         iface2 = netns_desc.create("NodeInterface")
  84         iface2.set_attribute_value("up", True)
  85         node2.connector("devs").connect(iface2.connector("node"))
  86         ip2 = iface2.add_address()
  87         ip2.set_attribute_value("Address", "10.0.0.2")
  88         switch = netns_desc.create("Switch")
  89         switch.set_attribute_value("up", True)
  90         iface1.connector("switch").connect(switch.connector("devs"))
  91         iface2.connector("switch").connect(switch.connector("devs"))
  92         app = netns_desc.create("Application")
  93         app.set_attribute_value("command", "ping -qc1 10.0.0.2")
  94         app.set_attribute_value("user", user)
  95         app.connector("node").connect(node1.connector("apps"))
  96         app.enable_trace("stdout")
  97         xml = exp_desc.to_xml()
  98
  99         access_config = proxy.AccessConfiguration()
 100         access_config.set_attribute_value("mode",
 101                 proxy.AccessConfiguration.MODE_DAEMON)
 102         access_config.set_attribute_value("rootDirectory", self.root_dir)
 103         access_config.set_attribute_value("logLevel",
 104                 proxy.AccessConfiguration.DEBUG_LEVEL)
 105         controller = proxy.create_controller(xml, access_config)
 106
 107         access_config2 = proxy.AccessConfiguration()
 108         access_config2.set_attribute_value("mode",
 109                 proxy.AccessConfiguration.MODE_DAEMON)
 110         inst_root_dir = os.path.join(self.root_dir, "instance")
 111         os.mkdir(inst_root_dir)
 112         access_config2.set_attribute_value("rootDirectory", inst_root_dir)
 113         access_config2.set_attribute_value("logLevel",
 114                 proxy.AccessConfiguration.DEBUG_LEVEL)
 115         controller.set_access_configuration(netns_desc.guid, access_config2)
 116
 117         controller.start()
 118         while not controller.is_finished(app.guid):
 119             time.sleep(0.5)
 120         ping_result = controller.trace(netns_desc.guid, app.guid, "stdout")
 121         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 122
 123 --- 10.0.0.2 ping statistics ---
 124 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 125 """
 126         self.assertTrue(ping_result.startswith(comp_result))
 127         controller.stop()
 128         controller.shutdown()
 129
 130     @test_util.skipUnless(os.getuid() == 0, "Test requires root privileges")
 131     def test_all_ssh_daemonized_if(self):
 132         exp_desc = ExperimentDescription()
 133         testbed_version = "01"
 134         testbed_id = "netns"
 135         env = test_util.test_environment()
 136         user = getpass.getuser()
 137         netns_provider = FactoriesProvider(testbed_id, testbed_version)
 138         netns_desc = exp_desc.add_testbed_description(netns_provider)
 139         netns_desc.set_attribute_value("homeDirectory", self.root_dir)
 140         #netns_desc.set_attribute_value("enableDebug", True)
 141         node1 = netns_desc.create("Node")
 142         node2 = netns_desc.create("Node")
 143         iface1 = netns_desc.create("NodeInterface")
 144         iface1.set_attribute_value("up", True)
 145         node1.connector("devs").connect(iface1.connector("node"))
 146         ip1 = iface1.add_address()
 147         ip1.set_attribute_value("Address", "10.0.0.1")
 148         iface2 = netns_desc.create("NodeInterface")
 149         iface2.set_attribute_value("up", True)
 150         node2.connector("devs").connect(iface2.connector("node"))
 151         ip2 = iface2.add_address()
 152         ip2.set_attribute_value("Address", "10.0.0.2")
 153         switch = netns_desc.create("Switch")
 154         switch.set_attribute_value("up", True)
 155         iface1.connector("switch").connect(switch.connector("devs"))
 156         iface2.connector("switch").connect(switch.connector("devs"))
 157         app = netns_desc.create("Application")
 158         app.set_attribute_value("command", "ping -qc1 10.0.0.2")
 159         app.set_attribute_value("user", user)
 160         app.connector("node").connect(node1.connector("apps"))
 161         app.enable_trace("stdout")
 162         xml = exp_desc.to_xml()
 163
 164         access_config = proxy.AccessConfiguration()
 165         access_config.set_attribute_value("mode",
 166                 proxy.AccessConfiguration.MODE_DAEMON)
 167         access_config.set_attribute_value("rootDirectory", self.root_dir)
 168         access_config.set_attribute_value("logLevel",
 169                 proxy.AccessConfiguration.DEBUG_LEVEL)
 170         access_config.set_attribute_value("communication",
 171                 proxy.AccessConfiguration.ACCESS_SSH)
 172         access_config.set_attribute_value("port", env.port)
 173         access_config.set_attribute_value("useAgent", True)
 174         controller = proxy.create_controller(xml, access_config)
 175
 176         access_config2 = proxy.AccessConfiguration()
 177         access_config2.set_attribute_value("mode",
 178                 proxy.AccessConfiguration.MODE_DAEMON)
 179         inst_root_dir = os.path.join(self.root_dir, "instance")
 180         os.mkdir(inst_root_dir)
 181         access_config2.set_attribute_value("rootDirectory", inst_root_dir)
 182         access_config2.set_attribute_value("logLevel",
 183                 proxy.AccessConfiguration.DEBUG_LEVEL)
 184         controller.set_access_configuration(netns_desc.guid, access_config2)
 185
 186         controller.start()
 187         while not controller.is_finished(app.guid):
 188             time.sleep(0.5)
 189         ping_result = controller.trace(netns_desc.guid, app.guid, "stdout")
 190         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 191
 192 --- 10.0.0.2 ping statistics ---
 193 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 194 """
 195         self.assertTrue(ping_result.startswith(comp_result))
 196         controller.stop()
 197         controller.shutdown()
 198
 199     def tearDown(self):
 200         shutil.rmtree(self.root_dir)
 201
 202 if __name__ == '__main__':
 203     unittest.main()
 204