test/resources/linux/application.py

   1 #!/usr/bin/env python
   2 from neco.execution.ec import ExperimentController
   3 from neco.execution.resource import ResourceState
   4 from neco.execution.trace import TraceAttr
   5 from neco.resources.linux.node import LinuxNode
   6 from neco.resources.linux.application import LinuxApplication
   7
   8 from test_utils import skipIfNotAlive
   9
  10 import os
  11 import time
  12 import tempfile
  13 import unittest
  14
  15 class LinuxApplicationTestCase(unittest.TestCase):
  16     def setUp(self):
  17         self.fedora_host = 'nepi2.pl.sophia.inria.fr'
  18         self.fedora_user = 'inria_nepi'
  19
  20         self.ubuntu_host = 'roseval.pl.sophia.inria.fr'
  21         self.ubuntu_user = 'alina'
  22
  23         self.target = 'nepi5.pl.sophia.inria.fr'
  24
  25     @skipIfNotAlive
  26     def t_ping(self, host, user):
  27         from neco.execution.resource import ResourceFactory
  28
  29         ResourceFactory.register_type(LinuxNode)
  30         ResourceFactory.register_type(LinuxApplication)
  31
  32         ec = ExperimentController()
  33
  34         node = ec.register_resource("LinuxNode")
  35         ec.set(node, "hostname", host)
  36         ec.set(node, "username", user)
  37         ec.set(node, "cleanHome", True)
  38         ec.set(node, "cleanProcesses", True)
  39
  40         app = ec.register_resource("LinuxApplication")
  41         cmd = "ping -c5 %s" % self.target
  42         ec.set(app, "command", cmd)
  43
  44         ec.register_connection(app, node)
  45
  46         try:
  47             ec.deploy()
  48
  49             while not ec.state(app) == ResourceState.FINISHED:
  50                 time.sleep(0.5)
  51
  52             self.assertTrue(ec.state(node) == ResourceState.STARTED)
  53             self.assertTrue(ec.state(app) == ResourceState.FINISHED)
  54
  55             stdout = ec.trace(app, 'stdout')
  56             size = ec.trace(app, 'stdout', attr = TraceAttr.SIZE)
  57             self.assertEquals(len(stdout), size)
  58
  59             block = ec.trace(app, 'stdout', attr = TraceAttr.STREAM, block = 5, offset = 1)
  60             self.assertEquals(block, stdout[5:10])
  61
  62             path = ec.trace(app, 'stdout', attr = TraceAttr.PATH)
  63             rm = ec.get_resource(app)
  64             p = os.path.join(rm.home, 'stdout')
  65             self.assertEquals(path, p)
  66
  67         finally:
  68             ec.shutdown()
  69
  70     @skipIfNotAlive
  71     def t_concurrency(self, host, user):
  72         from neco.execution.resource import ResourceFactory
  73
  74         ResourceFactory.register_type(LinuxNode)
  75         ResourceFactory.register_type(LinuxApplication)
  76
  77         ec = ExperimentController()
  78
  79         node = ec.register_resource("LinuxNode")
  80         ec.set(node, "hostname", host)
  81         ec.set(node, "username", user)
  82         ec.set(node, "cleanHome", True)
  83         ec.set(node, "cleanProcesses", True)
  84
  85         apps = list()
  86         for i in xrange(50):
  87             app = ec.register_resource("LinuxApplication")
  88             cmd = "ping -c5 %s" % self.target
  89             ec.set(app, "command", cmd)
  90             ec.register_connection(app, node)
  91             apps.append(app)
  92
  93         try:
  94             ec.deploy()
  95
  96             while not all([ec.state(guid) == ResourceState.FINISHED \
  97                     for guid in apps]):
  98                 time.sleep(0.5)
  99
 100             self.assertTrue(ec.state(node) == ResourceState.STARTED)
 101             self.assertTrue(
 102                    all([ec.state(guid) == ResourceState.FINISHED \
 103                     for guid in apps])
 104                     )
 105
 106             for app in apps:
 107                 stdout = ec.trace(app, 'stdout')
 108                 size = ec.trace(app, 'stdout', attr = TraceAttr.SIZE)
 109                 self.assertEquals(len(stdout), size)
 110
 111                 block = ec.trace(app, 'stdout', attr = TraceAttr.STREAM, block = 5, offset = 1)
 112                 self.assertEquals(block, stdout[5:10])
 113
 114                 path = ec.trace(app, 'stdout', attr = TraceAttr.PATH)
 115                 rm = ec.get_resource(app)
 116                 p = os.path.join(rm.home, 'stdout')
 117                 self.assertEquals(path, p)
 118
 119         finally:
 120             ec.shutdown()
 121
 122     def test_ping_fedora(self):
 123         self.t_ping(self.fedora_host, self.fedora_user)
 124
 125     def test_fing_ubuntu(self):
 126         self.t_ping(self.ubuntu_host, self.ubuntu_user)
 127
 128     def test_concurrency_fedora(self):
 129         self.t_concurrency(self.fedora_host, self.fedora_user)
 130
 131     def test_concurrency_ubuntu(self):
 132         self.t_concurrency(self.ubuntu_host, self.ubuntu_user)
 133
 134
 135 if __name__ == '__main__':
 136     unittest.main()
 137