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