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, tags
   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(desc1.guid, iface12.guid, "cross")
  82         cross2 = controller.get(desc2.guid, 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(desc.guid, 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         self.assertEquals(controller.get_tags(desc.guid, node1.guid), [tags.MOBILE])
 104
 105         controller.stop()
 106         controller.shutdown()
 107
 108     def test_daemonized_controller_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(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 113         access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir)
 114         controller = proxy.create_controller(xml, access_config)
 115
 116         controller.start()
 117         while not controller.is_finished(app.guid):
 118             time.sleep(0.5)
 119         fake_result = controller.trace(desc.guid, app.guid, "fake")
 120         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 121
 122 --- 10.0.0.2 ping statistics ---
 123 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 124 """
 125         self.assertTrue(fake_result.startswith(comp_result))
 126         self.assertEquals(controller.get_tags(desc.guid, node1.guid), [tags.MOBILE])
 127
 128         controller.stop()
 129         controller.shutdown()
 130
 131     def test_daemonized_testbed_integration(self):
 132         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 133
 134         desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 135         desc.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir)
 136
 137         xml = exp_desc.to_xml()
 138
 139         controller = proxy.create_controller(xml, access_config = None)
 140
 141         controller.start()
 142         while not controller.is_finished(app.guid):
 143             time.sleep(0.5)
 144         fake_result = controller.trace(desc.guid, app.guid, "fake")
 145         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 146
 147 --- 10.0.0.2 ping statistics ---
 148 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 149 """
 150         self.assertTrue(fake_result.startswith(comp_result))
 151         self.assertEquals(controller.get_tags(desc.guid, node1.guid), [tags.MOBILE])
 152
 153         controller.stop()
 154         controller.shutdown()
 155
 156     def test_daemonized_all_integration(self):
 157         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 158
 159         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         desc.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir)
 163
 164         xml = exp_desc.to_xml()
 165
 166         access_config = proxy.AccessConfiguration()
 167         access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 168         access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir)
 169         controller = proxy.create_controller(xml, access_config)
 170
 171         controller.start()
 172         while not controller.is_finished(app.guid):
 173             time.sleep(0.5)
 174         fake_result = controller.trace(desc.guid, app.guid, "fake")
 175         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 176
 177 --- 10.0.0.2 ping statistics ---
 178 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 179 """
 180         self.assertTrue(fake_result.startswith(comp_result))
 181         self.assertEquals(controller.get_tags(desc.guid, node1.guid), [tags.MOBILE])
 182
 183         controller.stop()
 184         controller.shutdown()
 185
 186     def test_daemonized_all_integration_recovery(self):
 187         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 188
 189         desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 190         inst_root_dir = os.path.join(self.root_dir, "instance")
 191         os.mkdir(inst_root_dir)
 192         desc.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir)
 193
 194         xml = exp_desc.to_xml()
 195
 196         access_config = proxy.AccessConfiguration()
 197         access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 198         access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir)
 199         controller = proxy.create_controller(xml, access_config)
 200
 201         controller.start()
 202         while not controller.is_finished(app.guid):
 203             time.sleep(0.5)
 204         fake_result = controller.trace(desc.guid, app.guid, "fake")
 205         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 206
 207 --- 10.0.0.2 ping statistics ---
 208 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 209 """
 210         self.assertTrue(fake_result.startswith(comp_result))
 211         self.assertEquals(controller.get_tags(desc.guid, node1.guid), [tags.MOBILE])
 212
 213         # controller dies
 214         del controller
 215
 216         # recover
 217         access_config.set_attribute_value(DC.RECOVER,True)
 218         controller = proxy.create_controller(xml, access_config)
 219
 220         # test recovery
 221         self.assertTrue(controller.is_finished(app.guid))
 222         fake_result = controller.trace(desc.guid, app.guid, "fake")
 223         self.assertTrue(fake_result.startswith(comp_result))
 224
 225         controller.stop()
 226         controller.shutdown()
 227
 228     def test_reference_expressions(self):
 229         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 230
 231         iface1.set_attribute_value("label", "some")
 232         addr = iface1.add_address()
 233         addr.set_attribute_value("Address", "10.0.0.2")
 234         iface2.set_attribute_value("test", "{#[some].addr[0].[Address]#}")
 235
 236         xml = exp_desc.to_xml()
 237         access_config = None
 238         controller = proxy.create_controller(xml, access_config)
 239         controller.start()
 240         while not controller.is_finished(app.guid):
 241             time.sleep(0.5)
 242         fake_result = controller.trace(desc.guid, app.guid, "fake")
 243         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 244
 245 --- 10.0.0.2 ping statistics ---
 246 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 247 """
 248
 249         self.assertTrue(fake_result.startswith(comp_result))
 250
 251         self.assertEqual(
 252             controller._testbeds[desc.guid].get(iface2.guid, "test"),
 253             addr.get_attribute_value("Address") )
 254
 255         controller.stop()
 256         controller.shutdown()
 257
 258     def test_testbed_reference_expressions(self):
 259         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 260
 261         iface1.set_attribute_value("label", "some")
 262         addr = iface1.add_address()
 263         addr.set_attribute_value("Address", "10.0.0.2")
 264
 265         desc2 = exp_desc.add_testbed_description(
 266             FactoriesProvider("mock2", "01") )
 267         desc2.set_attribute_value(DC.DEPLOYMENT_HOST, "{#[some].addr[0].[Address]#}")
 268         # DC.DEPLOYMENT_HOST should be ignored if DC.DEPLOYMENT_CONNECTION is not set
 269         # But it should be resolved anyway
 270
 271         xml = exp_desc.to_xml()
 272         access_config = None
 273         controller = proxy.create_controller(xml, access_config)
 274         controller.start()
 275         while not controller.is_finished(app.guid):
 276             time.sleep(0.5)
 277         fake_result = controller.trace(desc.guid, app.guid, "fake")
 278         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 279
 280 --- 10.0.0.2 ping statistics ---
 281 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 282 """
 283         self.assertTrue(fake_result.startswith(comp_result))
 284
 285         self.assertEqual(
 286             controller._deployment_config[desc2.guid]
 287                 .get_attribute_value(DC.DEPLOYMENT_HOST),
 288             addr.get_attribute_value("Address") )
 289
 290         controller.stop()
 291         controller.shutdown()
 292
 293     def TODO_test_ssh_daemonized_all_integration(self):
 294         # TODO: This test doesn't run because
 295         # sys.modules["nepi.testbeds.mock"] = mock
 296         # is not set in the ssh process
 297         exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
 298         env = test_util.test_environment()
 299
 300         desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 301         inst_root_dir = os.path.join(self.root_dir, "instance")
 302         os.mkdir(inst_root_dir)
 303         desc.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir)
 304         desc.set_attribute_value(DC.DEPLOYMENT_COMMUNICATION, DC.ACCESS_SSH)
 305         desc.set_attribute_value(DC.DEPLOYMENT_PORT, env.port)
 306         desc.set_attribute_value(DC.USE_AGENT, True)
 307
 308         xml = exp_desc.to_xml()
 309
 310         access_config = proxy.AccessConfiguration()
 311         access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 312         access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir)
 313         access_config.set_attribute_value(DC.DEPLOYMENT_COMMUNICATION, DC.ACCESS_SSH)
 314         access_config.set_attribute_value(DC.DEPLOYMENT_PORT, env.port)
 315         access_config.set_attribute_value(DC.USE_AGENT, True)
 316         controller = proxy.create_controller(xml, access_config)
 317
 318         controller.start()
 319         while not controller.is_finished(app.guid):
 320             time.sleep(0.5)
 321         fake_result = controller.trace(desc.guid, app.guid, "fake")
 322         comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
 323
 324 --- 10.0.0.2 ping statistics ---
 325 1 packets transmitted, 1 received, 0% packet loss, time 0ms
 326 """
 327         self.assertTrue(fake_result.startswith(comp_result))
 328         controller.stop()
 329         controller.shutdown()
 330
 331 if __name__ == '__main__':
 332     unittest.main()
 333