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 import proxy
   6 from nepi.util.constants import STATUS_FINISHED, DeploymentConfiguration as DC
   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         try:
  29             shutil.rmtree(self.root_dir)
  30         except:
  31             # retry
  32             time.sleep(0.1)
  33             shutil.rmtree(self.root_dir)
  34
  35     def make_testbed(self, exp_desc, testbed_id, testbed_version):
  36         provider = FactoriesProvider(testbed_id, testbed_version)
  37         desc = exp_desc.add_testbed_description(provider)
  38         desc.set_attribute_value("fake", True)
  39         node1 = desc.create("Node")
  40         node2 = desc.create("Node")
  41         iface1 = desc.create("Interface")
  42         iface1.set_attribute_value("fake", True)
  43         node1.connector("devs").connect(iface1.connector("node"))
  44         iface2 = desc.create("Interface")
  45         iface2.set_attribute_value("fake", True)
  46         node2.connector("devs").connect(iface2.connector("node"))
  47         iface1.connector("iface").connect(iface2.connector("iface"))
  48         app = desc.create("Application")
  49         app.connector("node").connect(node1.connector("apps"))
  50         app.enable_trace("fake")
  51
  52         return exp_desc, desc, app, node1, node2, iface1, iface2
  53
  54     def make_test_experiment(self):
  55         exp_desc = ExperimentDescription()
  56         testbed_version = "01"
  57         testbed_id = "mock"
  58         return self.make_testbed(exp_desc, testbed_id, testbed_version)
  59
  60     def make_cross_test_experiment(self):
  61         exp_desc = ExperimentDescription()
  62         testbed_version = "01"
  63         testbed_id1 = "mock"
  64         testbed_id2 = "mock2"
  65         exp_desc, desc1, app1, node11, node12, iface11, iface12 = \
  66                 self.make_testbed(exp_desc, testbed_id1, testbed_version)
  67         exp_desc, desc2, app2, node21, node22, iface21, iface22 = \
  68                  self.make_testbed(exp_desc, testbed_id2, testbed_version)
  69         iface12.connector("cross").connect(iface21.connector("cross"))
  70
  71         return exp_desc, desc1, desc2, iface12, iface21
  72
  73     def test_single_process_cross_integration(self):
  74         exp_desc, desc1, desc2, iface12, iface21 = \
  75                 self.make_cross_test_experiment()
  76         xml = exp_desc.to_xml()
  77         access_config = None
  78         controller = proxy.create_controller(xml, access_config)
  79
  80         controller.start()
  81         cross1 = controller.get(iface12.guid, "cross")
  82         cross2 = controller.get(iface21.guid, "cross")
  83         self.assertTrue(cross1 == cross2 == True)
  84         controller.stop()
  85         controller.shutdown()
  86
  87     def test_single_process_integration(self):
  88         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
  89         xml = exp_desc.to_xml()
  90         access_config = None
  91         controller = proxy.create_controller(xml, access_config)
  92
  93         controller.start()
  94         while not controller.is_finished(app.guid):
  95             time.sleep(0.5)
  96         fake_result = controller.trace(app.guid, "fake")
  97         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
  98
  99 --- 10.0.0.2 ping statistics ---
 100 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 101 """
 102         self.assertTrue(fake_result.startswith(comp_result))
 103
 104         self.assertEquals(controller.get_testbed_id(node1.guid), "mock")
 105         self.assertEquals(controller.get_testbed_version(node1.guid), "01")
 106         self.assertEquals(controller.get_factory_id(node1.guid), "Node")
 107
 108         controller.stop()
 109         controller.shutdown()
 110
 111     def test_daemonized_controller_integration(self):
 112         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 113         xml = exp_desc.to_xml()
 114         access_config = proxy.AccessConfiguration()
 115         access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 116         access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir)
 117         controller = proxy.create_controller(xml, access_config)
 118
 119         controller.start()
 120         while not controller.is_finished(app.guid):
 121             time.sleep(0.5)
 122         fake_result = controller.trace(app.guid, "fake")
 123         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 124
 125 --- 10.0.0.2 ping statistics ---
 126 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 127 """
 128         self.assertTrue(fake_result.startswith(comp_result))
 129
 130         self.assertEquals(controller.get_testbed_id(node1.guid), "mock")
 131         self.assertEquals(controller.get_testbed_version(node1.guid), "01")
 132         self.assertEquals(controller.get_factory_id(node1.guid), "Node")
 133
 134         controller.stop()
 135         controller.shutdown()
 136
 137     def test_daemonized_testbed_integration(self):
 138         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 139
 140         desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 141         desc.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir)
 142
 143         xml = exp_desc.to_xml()
 144
 145         controller = proxy.create_controller(xml, access_config = None)
 146
 147         controller.start()
 148         while not controller.is_finished(app.guid):
 149             time.sleep(0.5)
 150         fake_result = controller.trace(app.guid, "fake")
 151         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 152
 153 --- 10.0.0.2 ping statistics ---
 154 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 155 """
 156         self.assertTrue(fake_result.startswith(comp_result))
 157
 158         self.assertEquals(controller.get_testbed_id(node1.guid), "mock")
 159         self.assertEquals(controller.get_testbed_version(node1.guid), "01")
 160         self.assertEquals(controller.get_factory_id(node1.guid), "Node")
 161
 162         controller.stop()
 163         controller.shutdown()
 164
 165     def test_daemonized_all_integration(self):
 166         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 167
 168         desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 169         inst_root_dir = os.path.join(self.root_dir, "instance")
 170         os.mkdir(inst_root_dir)
 171         desc.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir)
 172
 173         xml = exp_desc.to_xml()
 174
 175         access_config = proxy.AccessConfiguration()
 176         access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 177         access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir)
 178         controller = proxy.create_controller(xml, access_config)
 179
 180         controller.start()
 181         while not controller.is_finished(app.guid):
 182             time.sleep(0.5)
 183         fake_result = controller.trace(app.guid, "fake")
 184         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 185
 186 --- 10.0.0.2 ping statistics ---
 187 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 188 """
 189         self.assertTrue(fake_result.startswith(comp_result))
 190
 191         self.assertEquals(controller.get_testbed_id(node1.guid), "mock")
 192         self.assertEquals(controller.get_testbed_version(node1.guid), "01")
 193         self.assertEquals(controller.get_factory_id(node1.guid), "Node")
 194
 195         controller.stop()
 196         controller.shutdown()
 197
 198     def test_daemonized_all_integration_recovery(self):
 199         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 200
 201         desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 202         inst_root_dir = os.path.join(self.root_dir, "instance")
 203         os.mkdir(inst_root_dir)
 204         desc.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir)
 205
 206         xml = exp_desc.to_xml()
 207
 208         access_config = proxy.AccessConfiguration()
 209         access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 210         access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir)
 211         controller = proxy.create_controller(xml, access_config)
 212
 213         controller.start()
 214         while not controller.is_finished(app.guid):
 215             time.sleep(0.5)
 216         fake_result = controller.trace(app.guid, "fake")
 217         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 218
 219 --- 10.0.0.2 ping statistics ---
 220 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 221 """
 222         self.assertTrue(fake_result.startswith(comp_result))
 223
 224         self.assertEquals(controller.get_testbed_id(node1.guid), "mock")
 225         self.assertEquals(controller.get_testbed_version(node1.guid), "01")
 226         self.assertEquals(controller.get_factory_id(node1.guid), "Node")
 227
 228         # controller dies
 229         del controller
 230
 231         # recover
 232         access_config.set_attribute_value(DC.RECOVER,True)
 233         controller = proxy.create_controller(xml, access_config)
 234
 235         # test recovery
 236         self.assertTrue(controller.is_finished(app.guid))
 237         fake_result = controller.trace(app.guid, "fake")
 238         self.assertTrue(fake_result.startswith(comp_result))
 239
 240         controller.stop()
 241         controller.shutdown()
 242
 243     def test_reference_expressions(self):
 244         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 245
 246         iface1.set_attribute_value("label", "some")
 247         addr = iface1.add_address()
 248         addr.set_attribute_value("Address", "10.0.0.2")
 249         iface2.set_attribute_value("test", "{#[some].addr[0].[Address]#}")
 250
 251         xml = exp_desc.to_xml()
 252         access_config = None
 253         controller = proxy.create_controller(xml, access_config)
 254         controller.start()
 255         while not controller.is_finished(app.guid):
 256             time.sleep(0.5)
 257         fake_result = controller.trace(app.guid, "fake")
 258         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 259
 260 --- 10.0.0.2 ping statistics ---
 261 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 262 """
 263
 264         self.assertTrue(fake_result.startswith(comp_result))
 265
 266         self.assertEqual(
 267             controller._testbeds[desc.guid].get(iface2.guid, "test"),
 268             addr.get_attribute_value("Address") )
 269
 270         controller.stop()
 271         controller.shutdown()
 272
 273     def test_testbed_reference_expressions(self):
 274         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 275
 276         iface1.set_attribute_value("label", "some")
 277         addr = iface1.add_address()
 278         addr.set_attribute_value("Address", "10.0.0.2")
 279
 280         desc2 = exp_desc.add_testbed_description(
 281             FactoriesProvider("mock2", "01") )
 282         desc2.set_attribute_value(DC.DEPLOYMENT_HOST, "{#[some].addr[0].[Address]#}")
 283         # DC.DEPLOYMENT_HOST should be ignored if DC.DEPLOYMENT_CONNECTION is not set
 284         # But it should be resolved anyway
 285
 286         xml = exp_desc.to_xml()
 287         access_config = None
 288         controller = proxy.create_controller(xml, access_config)
 289         controller.start()
 290         while not controller.is_finished(app.guid):
 291             time.sleep(0.5)
 292         fake_result = controller.trace(app.guid, "fake")
 293         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 294
 295 --- 10.0.0.2 ping statistics ---
 296 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 297 """
 298         self.assertTrue(fake_result.startswith(comp_result))
 299
 300         self.assertEqual(
 301             controller._deployment_config[desc2.guid]
 302                 .get_attribute_value(DC.DEPLOYMENT_HOST),
 303             addr.get_attribute_value("Address") )
 304
 305         controller.stop()
 306         controller.shutdown()
 307
 308     def TODO_test_ssh_daemonized_all_integration(self):
 309         # TODO: This test doesn't run because
 310         # sys.modules["nepi.testbeds.mock"] = mock
 311         # is not set in the ssh process
 312         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 313         env = test_util.test_environment()
 314
 315         desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 316         inst_root_dir = os.path.join(self.root_dir, "instance")
 317         os.mkdir(inst_root_dir)
 318         desc.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir)
 319         desc.set_attribute_value(DC.DEPLOYMENT_COMMUNICATION, DC.ACCESS_SSH)
 320         desc.set_attribute_value(DC.DEPLOYMENT_PORT, env.port)
 321         desc.set_attribute_value(DC.USE_AGENT, True)
 322
 323         xml = exp_desc.to_xml()
 324
 325         access_config = proxy.AccessConfiguration()
 326         access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 327         access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir)
 328         access_config.set_attribute_value(DC.DEPLOYMENT_COMMUNICATION, DC.ACCESS_SSH)
 329         access_config.set_attribute_value(DC.DEPLOYMENT_PORT, env.port)
 330         access_config.set_attribute_value(DC.USE_AGENT, True)
 331         controller = proxy.create_controller(xml, access_config)
 332
 333         controller.start()
 334         while not controller.is_finished(app.guid):
 335             time.sleep(0.5)
 336         fake_result = controller.trace(app.guid, "fake")
 337         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 338
 339 --- 10.0.0.2 ping statistics ---
 340 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 341 """
 342         self.assertTrue(fake_result.startswith(comp_result))
 343         controller.stop()
 344         controller.shutdown()
 345
 346 if __name__ == '__main__':
 347     unittest.main()
 348