test/core/integration.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 from nepi.core.design import ExperimentDescription, FactoriesProvider
   5 from nepi.util.constants import STATUS_FINISHED
   6 from nepi.util import proxy
   7 import mock
   8 import mock.metadata_v01
   9 import os
  10 import shutil
  11 import sys
  12 import tempfile
  13 import test_util
  14 import time
  15 import unittest
  16
  17 class ExecuteTestCase(unittest.TestCase):
  18     def setUp(self):
  19         sys.modules["nepi.testbeds.mock.metadata_v01"] = mock.metadata_v01
  20         sys.modules["nepi.testbeds.mock"] = mock
  21         self.root_dir = tempfile.mkdtemp()
  22
  23     def test_single_process_integration(self):
  24         exp_desc = ExperimentDescription()
  25         testbed_version = "01"
  26         testbed_id = "mock"
  27         provider = FactoriesProvider(testbed_id, testbed_version)
  28         desc = exp_desc.add_testbed_description(provider)
  29         desc.set_attribute_value("fake", True)
  30         node1 = desc.create("Node")
  31         node2 = desc.create("Node")
  32         iface1 = desc.create("Interface")
  33         iface1.set_attribute_value("fake", True)
  34         node1.connector("devs").connect(iface1.connector("node"))
  35         iface2 = desc.create("Interface")
  36         iface2.set_attribute_value("fake", True)
  37         node2.connector("devs").connect(iface2.connector("node"))
  38         iface1.connector("iface").connect(iface2.connector("iface"))
  39         app = desc.create("Application")
  40         app.connector("node").connect(node1.connector("apps"))
  41         app.enable_trace("fake")
  42
  43         xml = exp_desc.to_xml()
  44         access_config = None
  45         controller = proxy.create_controller(xml, access_config)
  46         controller.start()
  47         while not controller.is_finished(app.guid):
  48             time.sleep(0.5)
  49         fake_result = controller.trace(desc.guid, app.guid, "fake")
  50         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
  51
  52 --- 10.0.0.2 ping statistics ---
  53 1 packets transmitted, 1 received, 0% packet loss, time 0ms
  54 """
  55         self.assertTrue(fake_result.startswith(comp_result))
  56         controller.stop()
  57         controller.shutdown()
  58
  59     def test_daemonized_controller_integration(self):
  60         exp_desc = ExperimentDescription()
  61         testbed_version = "01"
  62         testbed_id = "mock"
  63         provider = FactoriesProvider(testbed_id, testbed_version)
  64         desc = exp_desc.add_testbed_description(provider)
  65         desc.set_attribute_value("fake", True)
  66         node1 = desc.create("Node")
  67         node2 = desc.create("Node")
  68         iface1 = desc.create("Interface")
  69         iface1.set_attribute_value("fake", True)
  70         node1.connector("devs").connect(iface1.connector("node"))
  71         iface2 = desc.create("Interface")
  72         iface2.set_attribute_value("fake", True)
  73         node2.connector("devs").connect(iface2.connector("node"))
  74         iface1.connector("iface").connect(iface2.connector("iface"))
  75         app = desc.create("Application")
  76         app.connector("node").connect(node1.connector("apps"))
  77         app.enable_trace("fake")
  78
  79         xml = exp_desc.to_xml()
  80         access_config = proxy.AccessConfiguration()
  81         access_config.set_attribute_value("mode",
  82                 proxy.AccessConfiguration.MODE_DAEMON)
  83         access_config.set_attribute_value("rootDirectory", self.root_dir)
  84         controller = proxy.create_controller(xml, access_config)
  85
  86         controller.start()
  87         while not controller.is_finished(app.guid):
  88             time.sleep(0.5)
  89         fake_result = controller.trace(desc.guid, app.guid, "fake")
  90         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
  91
  92 --- 10.0.0.2 ping statistics ---
  93 1 packets transmitted, 1 received, 0% packet loss, time 0ms
  94 """
  95         self.assertTrue(fake_result.startswith(comp_result))
  96         controller.stop()
  97         controller.shutdown()
  98
  99     def test_daemonized_testbed_integration(self):
 100         exp_desc = ExperimentDescription()
 101         testbed_version = "01"
 102         testbed_id = "mock"
 103         provider = FactoriesProvider(testbed_id, testbed_version)
 104         desc = exp_desc.add_testbed_description(provider)
 105         desc.set_attribute_value("fake", True)
 106         node1 = desc.create("Node")
 107         node2 = desc.create("Node")
 108         iface1 = desc.create("Interface")
 109         iface1.set_attribute_value("fake", True)
 110         node1.connector("devs").connect(iface1.connector("node"))
 111         iface2 = desc.create("Interface")
 112         iface2.set_attribute_value("fake", True)
 113         node2.connector("devs").connect(iface2.connector("node"))
 114         iface1.connector("iface").connect(iface2.connector("iface"))
 115         app = desc.create("Application")
 116         app.connector("node").connect(node1.connector("apps"))
 117         app.enable_trace("fake")
 118
 119         xml = exp_desc.to_xml()
 120         controller = proxy.create_controller(xml, access_config = None)
 121         access_config = proxy.AccessConfiguration()
 122         access_config.set_attribute_value("mode",
 123                 proxy.AccessConfiguration.MODE_DAEMON)
 124         access_config.set_attribute_value("rootDirectory", self.root_dir)
 125         controller.set_access_configuration(desc.guid, access_config)
 126
 127         controller.start()
 128         while not controller.is_finished(app.guid):
 129             time.sleep(0.5)
 130         fake_result = controller.trace(desc.guid, app.guid, "fake")
 131         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 132
 133 --- 10.0.0.2 ping statistics ---
 134 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 135 """
 136         self.assertTrue(fake_result.startswith(comp_result))
 137         controller.stop()
 138         controller.shutdown()
 139
 140     def test_daemonized_all_integration(self):
 141         exp_desc = ExperimentDescription()
 142         testbed_version = "01"
 143         testbed_id = "mock"
 144         provider = FactoriesProvider(testbed_id, testbed_version)
 145         desc = exp_desc.add_testbed_description(provider)
 146         desc.set_attribute_value("fake", True)
 147         node1 = desc.create("Node")
 148         node2 = desc.create("Node")
 149         iface1 = desc.create("Interface")
 150         iface1.set_attribute_value("fake", True)
 151         node1.connector("devs").connect(iface1.connector("node"))
 152         iface2 = desc.create("Interface")
 153         iface2.set_attribute_value("fake", True)
 154         node2.connector("devs").connect(iface2.connector("node"))
 155         iface1.connector("iface").connect(iface2.connector("iface"))
 156         app = desc.create("Application")
 157         app.connector("node").connect(node1.connector("apps"))
 158         app.enable_trace("fake")
 159
 160         xml = exp_desc.to_xml()
 161         access_config = proxy.AccessConfiguration()
 162         access_config.set_attribute_value("mode",
 163                 proxy.AccessConfiguration.MODE_DAEMON)
 164         access_config.set_attribute_value("rootDirectory", self.root_dir)
 165         controller = proxy.create_controller(xml, access_config)
 166
 167         access_config2 = proxy.AccessConfiguration()
 168         access_config2.set_attribute_value("mode",
 169                 proxy.AccessConfiguration.MODE_DAEMON)
 170         inst_root_dir = os.path.join(self.root_dir, "instance")
 171         os.mkdir(inst_root_dir)
 172         access_config2.set_attribute_value("rootDirectory", inst_root_dir)
 173         controller.set_access_configuration(desc.guid, access_config2)
 174
 175         controller.start()
 176         while not controller.is_finished(app.guid):
 177             time.sleep(0.5)
 178         fake_result = controller.trace(desc.guid, app.guid, "fake")
 179         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 180
 181 --- 10.0.0.2 ping statistics ---
 182 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 183 """
 184         self.assertTrue(fake_result.startswith(comp_result))
 185         controller.stop()
 186         controller.shutdown()
 187
 188     def TODO_test_ssh_daemonized_all_integration(self):
 189         # This test doesn't run because
 190         # sys.modules["nepi.testbeds.mock"] = mock
 191         # is not set in the ssh process
 192         exp_desc = ExperimentDescription()
 193         testbed_version = "01"
 194         testbed_id = "mock"
 195         env = test_util.test_environment()
 196         provider = FactoriesProvider(testbed_id, testbed_version)
 197         desc = exp_desc.add_testbed_description(provider)
 198         desc.set_attribute_value("fake", True)
 199         node1 = desc.create("Node")
 200         node2 = desc.create("Node")
 201         iface1 = desc.create("Interface")
 202         iface1.set_attribute_value("fake", True)
 203         node1.connector("devs").connect(iface1.connector("node"))
 204         iface2 = desc.create("Interface")
 205         iface2.set_attribute_value("fake", True)
 206         node2.connector("devs").connect(iface2.connector("node"))
 207         iface1.connector("iface").connect(iface2.connector("iface"))
 208         app = desc.create("Application")
 209         app.connector("node").connect(node1.connector("apps"))
 210         app.enable_trace("fake")
 211
 212         xml = exp_desc.to_xml()
 213         access_config = proxy.AccessConfiguration()
 214         access_config.set_attribute_value("mode",
 215                 proxy.AccessConfiguration.MODE_DAEMON)
 216         access_config.set_attribute_value("rootDirectory", self.root_dir)
 217         access_config.set_attribute_value("communication",
 218                 proxy.AccessConfiguration.ACCESS_SSH)
 219         access_config.set_attribute_value("port", env.port)
 220         access_config.set_attribute_value("useAgent", True)
 221         controller = proxy.create_controller(xml, access_config)
 222
 223         access_config2 = proxy.AccessConfiguration()
 224         access_config2.set_attribute_value("mode",
 225                 proxy.AccessConfiguration.MODE_DAEMON)
 226         inst_root_dir = os.path.join(self.root_dir, "instance")
 227         os.mkdir(inst_root_dir)
 228         access_config2.set_attribute_value("rootDirectory", inst_root_dir)
 229         access_config2.set_attribute_value("communication",
 230                 proxy.AccessConfiguration.ACCESS_SSH)
 231         access_config2.set_attribute_value("port", env.port)
 232         access_config2.set_attribute_value("useAgent", True)
 233         controller.set_access_configuration(desc.guid, access_config2)
 234
 235         controller.start()
 236         while not controller.is_finished(app.guid):
 237             time.sleep(0.5)
 238         fake_result = controller.trace(desc.guid, app.guid, "fake")
 239         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 240
 241 --- 10.0.0.2 ping statistics ---
 242 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 243 """
 244         self.assertTrue(fake_result.startswith(comp_result))
 245         controller.stop()
 246         controller.shutdown()
 247
 248     def tearDown(self):
 249         shutil.rmtree(self.root_dir)
 250
 251 if __name__ == '__main__':
 252     unittest.main()
 253