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 mock2
  10 import mock2.metadata_v01
  11 import os
  12 import shutil
  13 import sys
  14 import tempfile
  15 import test_util
  16 import time
  17 import unittest
  18
  19 class ExecuteTestCase(unittest.TestCase):
  20     def setUp(self):
  21         sys.modules["nepi.testbeds.mock.metadata_v01"] = mock.metadata_v01
  22         sys.modules["nepi.testbeds.mock"] = mock
  23         sys.modules["nepi.testbeds.mock2.metadata_v01"] = mock2.metadata_v01
  24         sys.modules["nepi.testbeds.mock2"] = mock2
  25         self.root_dir = tempfile.mkdtemp()
  26
  27     def tearDown(self):
  28         shutil.rmtree(self.root_dir)
  29
  30     def make_testbed(self, exp_desc, testbed_id, testbed_version):
  31         provider = FactoriesProvider(testbed_id, testbed_version)
  32         desc = exp_desc.add_testbed_description(provider)
  33         desc.set_attribute_value("fake", True)
  34         node1 = desc.create("Node")
  35         node2 = desc.create("Node")
  36         iface1 = desc.create("Interface")
  37         iface1.set_attribute_value("fake", True)
  38         node1.connector("devs").connect(iface1.connector("node"))
  39         iface2 = desc.create("Interface")
  40         iface2.set_attribute_value("fake", True)
  41         node2.connector("devs").connect(iface2.connector("node"))
  42         iface1.connector("iface").connect(iface2.connector("iface"))
  43         app = desc.create("Application")
  44         app.connector("node").connect(node1.connector("apps"))
  45         app.enable_trace("fake")
  46
  47         return exp_desc, desc, app, node1, node2, iface1, iface2
  48
  49     def make_test_experiment(self):
  50         exp_desc = ExperimentDescription()
  51         testbed_version = "01"
  52         testbed_id = "mock"
  53         return self.make_testbed(exp_desc, testbed_id, testbed_version)
  54
  55     def make_cross_test_experiment(self):
  56         exp_desc = ExperimentDescription()
  57         testbed_version = "01"
  58         testbed_id1 = "mock"
  59         testbed_id2 = "mock2"
  60         exp_desc, desc1, app1, node11, node12, iface11, iface12 = \
  61                 self.make_testbed(exp_desc, testbed_id1, testbed_version)
  62         exp_desc, desc2, app2, node21, node22, iface21, iface22 = \
  63                  self.make_testbed(exp_desc, testbed_id2, testbed_version)
  64         iface12.connector("cross").connect(iface21.connector("cross"))
  65
  66         return exp_desc, desc1, desc2, iface12, iface21
  67
  68     def test_single_process_cross_integration(self):
  69         exp_desc, desc1, desc2, iface12, iface21 = \
  70                 self.make_cross_test_experiment()
  71         xml = exp_desc.to_xml()
  72         access_config = None
  73         controller = proxy.create_controller(xml, access_config)
  74
  75         controller.start()
  76         cross1 = controller.get(desc1.guid, iface12.guid, "cross")
  77         cross2 = controller.get(desc2.guid, iface21.guid, "cross")
  78         self.assertTrue(cross1 == cross2 == True)
  79         controller.stop()
  80         controller.shutdown()
  81
  82     def test_single_process_integration(self):
  83         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
  84         xml = exp_desc.to_xml()
  85         access_config = None
  86         controller = proxy.create_controller(xml, access_config)
  87
  88         controller.start()
  89         while not controller.is_finished(app.guid):
  90             time.sleep(0.5)
  91         fake_result = controller.trace(desc.guid, app.guid, "fake")
  92         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
  93
  94 --- 10.0.0.2 ping statistics ---
  95 1 packets transmitted, 1 received, 0% packet loss, time 0ms
  96 """
  97         self.assertTrue(fake_result.startswith(comp_result))
  98         controller.stop()
  99         controller.shutdown()
 100
 101     def test_daemonized_controller_integration(self):
 102         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 103         xml = exp_desc.to_xml()
 104         access_config = proxy.AccessConfiguration()
 105         access_config.set_attribute_value("mode",
 106                 proxy.AccessConfiguration.MODE_DAEMON)
 107         access_config.set_attribute_value("rootDirectory", self.root_dir)
 108         controller = proxy.create_controller(xml, access_config)
 109
 110         controller.start()
 111         while not controller.is_finished(app.guid):
 112             time.sleep(0.5)
 113         fake_result = controller.trace(desc.guid, app.guid, "fake")
 114         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 115
 116 --- 10.0.0.2 ping statistics ---
 117 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 118 """
 119         self.assertTrue(fake_result.startswith(comp_result))
 120         controller.stop()
 121         controller.shutdown()
 122
 123     def test_daemonized_testbed_integration(self):
 124         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 125         xml = exp_desc.to_xml()
 126         controller = proxy.create_controller(xml, access_config = None)
 127         access_config = proxy.AccessConfiguration()
 128         access_config.set_attribute_value("mode",
 129                 proxy.AccessConfiguration.MODE_DAEMON)
 130         access_config.set_attribute_value("rootDirectory", self.root_dir)
 131         controller.set_access_configuration(desc.guid, access_config)
 132
 133         controller.start()
 134         while not controller.is_finished(app.guid):
 135             time.sleep(0.5)
 136         fake_result = controller.trace(desc.guid, app.guid, "fake")
 137         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 138
 139 --- 10.0.0.2 ping statistics ---
 140 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 141 """
 142         self.assertTrue(fake_result.startswith(comp_result))
 143         controller.stop()
 144         controller.shutdown()
 145
 146     def test_daemonized_all_integration(self):
 147         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 148         xml = exp_desc.to_xml()
 149         access_config = proxy.AccessConfiguration()
 150         access_config.set_attribute_value("mode",
 151                 proxy.AccessConfiguration.MODE_DAEMON)
 152         access_config.set_attribute_value("rootDirectory", self.root_dir)
 153         controller = proxy.create_controller(xml, access_config)
 154
 155         access_config2 = proxy.AccessConfiguration()
 156         access_config2.set_attribute_value("mode",
 157                 proxy.AccessConfiguration.MODE_DAEMON)
 158         inst_root_dir = os.path.join(self.root_dir, "instance")
 159         os.mkdir(inst_root_dir)
 160         access_config2.set_attribute_value("rootDirectory", inst_root_dir)
 161         controller.set_access_configuration(desc.guid, access_config2)
 162
 163         controller.start()
 164         while not controller.is_finished(app.guid):
 165             time.sleep(0.5)
 166         fake_result = controller.trace(desc.guid, app.guid, "fake")
 167         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 168
 169 --- 10.0.0.2 ping statistics ---
 170 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 171 """
 172         self.assertTrue(fake_result.startswith(comp_result))
 173         controller.stop()
 174         controller.shutdown()
 175
 176     def test_daemonized_all_integration_recovery(self):
 177         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 178         xml = exp_desc.to_xml()
 179         access_config = proxy.AccessConfiguration()
 180         access_config.set_attribute_value("mode",
 181                 proxy.AccessConfiguration.MODE_DAEMON)
 182         access_config.set_attribute_value("rootDirectory", self.root_dir)
 183         controller = proxy.create_controller(xml, access_config)
 184
 185         access_config2 = proxy.AccessConfiguration()
 186         access_config2.set_attribute_value("mode",
 187                 proxy.AccessConfiguration.MODE_DAEMON)
 188         inst_root_dir = os.path.join(self.root_dir, "instance")
 189         os.mkdir(inst_root_dir)
 190         access_config2.set_attribute_value("rootDirectory", inst_root_dir)
 191         controller.set_access_configuration(desc.guid, access_config2)
 192
 193         controller.start()
 194         while not controller.is_finished(app.guid):
 195             time.sleep(0.5)
 196         fake_result = controller.trace(desc.guid, app.guid, "fake")
 197         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 198
 199 --- 10.0.0.2 ping statistics ---
 200 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 201 """
 202         self.assertTrue(fake_result.startswith(comp_result))
 203
 204         # controller dies
 205         del controller
 206
 207         # recover
 208         access_config.set_attribute_value("recover",True)
 209         controller = proxy.create_controller(xml, access_config)
 210
 211         # test recovery
 212         self.assertTrue(controller.is_finished(app.guid))
 213         fake_result = controller.trace(desc.guid, app.guid, "fake")
 214         self.assertTrue(fake_result.startswith(comp_result))
 215
 216         controller.stop()
 217         controller.shutdown()
 218
 219     def test_reference_expressions(self):
 220         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 221
 222         iface1.set_attribute_value("label", "some")
 223         addr = iface1.add_address()
 224         addr.set_attribute_value("Address", "10.0.0.2")
 225         iface2.set_attribute_value("test", "{#[some].addr[0].[Address]#}")
 226
 227         # TODO: Test actual substitution
 228
 229         xml = exp_desc.to_xml()
 230         access_config = None
 231         controller = proxy.create_controller(xml, access_config)
 232         controller.start()
 233         while not controller.is_finished(app.guid):
 234             time.sleep(0.5)
 235         fake_result = controller.trace(desc.guid, app.guid, "fake")
 236         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 237
 238 --- 10.0.0.2 ping statistics ---
 239 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 240 """
 241         self.assertTrue(fake_result.startswith(comp_result))
 242         controller.stop()
 243         controller.shutdown()
 244
 245     def TODO_test_ssh_daemonized_all_integration(self):
 246         # TODO: This test doesn't run because
 247         # sys.modules["nepi.testbeds.mock"] = mock
 248         # is not set in the ssh process
 249         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 250         xml = exp_desc.to_xml()
 251         access_config = proxy.AccessConfiguration()
 252         access_config.set_attribute_value("mode",
 253                 proxy.AccessConfiguration.MODE_DAEMON)
 254         access_config.set_attribute_value("rootDirectory", self.root_dir)
 255         access_config.set_attribute_value("communication",
 256                 proxy.AccessConfiguration.ACCESS_SSH)
 257         access_config.set_attribute_value("port", env.port)
 258         access_config.set_attribute_value("useAgent", True)
 259         controller = proxy.create_controller(xml, access_config)
 260
 261         access_config2 = proxy.AccessConfiguration()
 262         access_config2.set_attribute_value("mode",
 263                 proxy.AccessConfiguration.MODE_DAEMON)
 264         inst_root_dir = os.path.join(self.root_dir, "instance")
 265         os.mkdir(inst_root_dir)
 266         access_config2.set_attribute_value("rootDirectory", inst_root_dir)
 267         access_config2.set_attribute_value("communication",
 268                 proxy.AccessConfiguration.ACCESS_SSH)
 269         access_config2.set_attribute_value("port", env.port)
 270         access_config2.set_attribute_value("useAgent", True)
 271         controller.set_access_configuration(desc.guid, access_config2)
 272
 273         controller.start()
 274         while not controller.is_finished(app.guid):
 275             time.sleep(0.5)
 276         fake_result = controller.trace(desc.guid, app.guid, "fake")
 277         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 278
 279 --- 10.0.0.2 ping statistics ---
 280 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 281 """
 282         self.assertTrue(fake_result.startswith(comp_result))
 283         controller.stop()
 284         controller.shutdown()
 285
 286 if __name__ == '__main__':
 287     unittest.main()
 288