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 make_test_experiment(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         return exp_desc, desc, app, node1, node2, iface1, iface2
  44
  45     def test_single_process_integration(self):
  46         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
  47         xml = exp_desc.to_xml()
  48         access_config = None
  49         controller = proxy.create_controller(xml, access_config)
  50         controller.start()
  51         while not controller.is_finished(app.guid):
  52             time.sleep(0.5)
  53         fake_result = controller.trace(desc.guid, app.guid, "fake")
  54         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
  55
  56 --- 10.0.0.2 ping statistics ---
  57 1 packets transmitted, 1 received, 0% packet loss, time 0ms
  58 """
  59         self.assertTrue(fake_result.startswith(comp_result))
  60         controller.stop()
  61         controller.shutdown()
  62
  63     def test_daemonized_controller_integration(self):
  64         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
  65         xml = exp_desc.to_xml()
  66         access_config = proxy.AccessConfiguration()
  67         access_config.set_attribute_value("mode",
  68                 proxy.AccessConfiguration.MODE_DAEMON)
  69         access_config.set_attribute_value("rootDirectory", self.root_dir)
  70         controller = proxy.create_controller(xml, access_config)
  71
  72         controller.start()
  73         while not controller.is_finished(app.guid):
  74             time.sleep(0.5)
  75         fake_result = controller.trace(desc.guid, app.guid, "fake")
  76         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
  77
  78 --- 10.0.0.2 ping statistics ---
  79 1 packets transmitted, 1 received, 0% packet loss, time 0ms
  80 """
  81         self.assertTrue(fake_result.startswith(comp_result))
  82         controller.stop()
  83         controller.shutdown()
  84
  85     def test_daemonized_testbed_integration(self):
  86         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
  87         xml = exp_desc.to_xml()
  88         controller = proxy.create_controller(xml, access_config = None)
  89         access_config = proxy.AccessConfiguration()
  90         access_config.set_attribute_value("mode",
  91                 proxy.AccessConfiguration.MODE_DAEMON)
  92         access_config.set_attribute_value("rootDirectory", self.root_dir)
  93         controller.set_access_configuration(desc.guid, access_config)
  94
  95         controller.start()
  96         while not controller.is_finished(app.guid):
  97             time.sleep(0.5)
  98         fake_result = controller.trace(desc.guid, app.guid, "fake")
  99         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 100
 101 --- 10.0.0.2 ping statistics ---
 102 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 103 """
 104         self.assertTrue(fake_result.startswith(comp_result))
 105         controller.stop()
 106         controller.shutdown()
 107
 108     def test_daemonized_all_integration(self):
 109         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 110         xml = exp_desc.to_xml()
 111         access_config = proxy.AccessConfiguration()
 112         access_config.set_attribute_value("mode",
 113                 proxy.AccessConfiguration.MODE_DAEMON)
 114         access_config.set_attribute_value("rootDirectory", self.root_dir)
 115         controller = proxy.create_controller(xml, access_config)
 116
 117         access_config2 = proxy.AccessConfiguration()
 118         access_config2.set_attribute_value("mode",
 119                 proxy.AccessConfiguration.MODE_DAEMON)
 120         inst_root_dir = os.path.join(self.root_dir, "instance")
 121         os.mkdir(inst_root_dir)
 122         access_config2.set_attribute_value("rootDirectory", inst_root_dir)
 123         controller.set_access_configuration(desc.guid, access_config2)
 124
 125         controller.start()
 126         while not controller.is_finished(app.guid):
 127             time.sleep(0.5)
 128         fake_result = controller.trace(desc.guid, app.guid, "fake")
 129         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 130
 131 --- 10.0.0.2 ping statistics ---
 132 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 133 """
 134         self.assertTrue(fake_result.startswith(comp_result))
 135         controller.stop()
 136         controller.shutdown()
 137
 138     def test_reference_expressions(self):
 139         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 140
 141         iface1.set_attribute_value("label", "some")
 142         addr = iface1.add_address()
 143         addr.set_attribute_value("Address", "10.0.0.2")
 144         iface2.set_attribute_value("test", "{#[some].addr[0].[Address]#}")
 145
 146         # TODO: Test actual substitution
 147
 148         xml = exp_desc.to_xml()
 149         access_config = None
 150         controller = proxy.create_controller(xml, access_config)
 151         controller.start()
 152         while not controller.is_finished(app.guid):
 153             time.sleep(0.5)
 154         fake_result = controller.trace(desc.guid, app.guid, "fake")
 155         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 156
 157 --- 10.0.0.2 ping statistics ---
 158 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 159 """
 160         self.assertTrue(fake_result.startswith(comp_result))
 161         controller.stop()
 162         controller.shutdown()
 163
 164     def TODO_test_ssh_daemonized_all_integration(self):
 165         # TODO: This test doesn't run because
 166         # sys.modules["nepi.testbeds.mock"] = mock
 167         # is not set in the ssh process
 168         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 169         xml = exp_desc.to_xml()
 170         access_config = proxy.AccessConfiguration()
 171         access_config.set_attribute_value("mode",
 172                 proxy.AccessConfiguration.MODE_DAEMON)
 173         access_config.set_attribute_value("rootDirectory", self.root_dir)
 174         access_config.set_attribute_value("communication",
 175                 proxy.AccessConfiguration.ACCESS_SSH)
 176         access_config.set_attribute_value("port", env.port)
 177         access_config.set_attribute_value("useAgent", True)
 178         controller = proxy.create_controller(xml, access_config)
 179
 180         access_config2 = proxy.AccessConfiguration()
 181         access_config2.set_attribute_value("mode",
 182                 proxy.AccessConfiguration.MODE_DAEMON)
 183         inst_root_dir = os.path.join(self.root_dir, "instance")
 184         os.mkdir(inst_root_dir)
 185         access_config2.set_attribute_value("rootDirectory", inst_root_dir)
 186         access_config2.set_attribute_value("communication",
 187                 proxy.AccessConfiguration.ACCESS_SSH)
 188         access_config2.set_attribute_value("port", env.port)
 189         access_config2.set_attribute_value("useAgent", True)
 190         controller.set_access_configuration(desc.guid, access_config2)
 191
 192         controller.start()
 193         while not controller.is_finished(app.guid):
 194             time.sleep(0.5)
 195         fake_result = controller.trace(desc.guid, app.guid, "fake")
 196         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 197
 198 --- 10.0.0.2 ping statistics ---
 199 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 200 """
 201         self.assertTrue(fake_result.startswith(comp_result))
 202         controller.stop()
 203         controller.shutdown()
 204
 205     def tearDown(self):
 206         shutil.rmtree(self.root_dir)
 207
 208 if __name__ == '__main__':
 209     unittest.main()
 210