test/resources/linux/application.py

   1 """
   2     NEPI, a framework to manage network experiments
   3     Copyright (C) 2013 INRIA
   4
   5     This program is free software: you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation, either version 3 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 """
  19
  20 #!/usr/bin/env python
  21 from nepi.execution.ec import ExperimentController
  22 from nepi.execution.resource import ResourceState, ResourceAction
  23 from nepi.execution.trace import TraceAttr
  24 from nepi.resources.linux.node import LinuxNode
  25 from nepi.resources.linux.application import LinuxApplication
  26
  27 from test_utils import skipIfNotAlive
  28
  29 import os
  30 import time
  31 import tempfile
  32 import unittest
  33
  34 class LinuxApplicationTestCase(unittest.TestCase):
  35     def setUp(self):
  36         self.fedora_host = 'nepi2.pl.sophia.inria.fr'
  37         self.fedora_user = 'inria_nepi'
  38
  39         self.ubuntu_host = 'roseval.pl.sophia.inria.fr'
  40         self.ubuntu_user = 'alina'
  41
  42         self.target = 'nepi5.pl.sophia.inria.fr'
  43
  44     @skipIfNotAlive
  45     def t_stdout(self, host, user):
  46         from nepi.execution.resource import ResourceFactory
  47
  48         ResourceFactory.register_type(LinuxNode)
  49         ResourceFactory.register_type(LinuxApplication)
  50
  51         ec = ExperimentController()
  52
  53         node = ec.register_resource("LinuxNode")
  54         ec.set(node, "hostname", host)
  55         ec.set(node, "username", user)
  56         ec.set(node, "cleanHome", True)
  57         ec.set(node, "cleanProcesses", True)
  58
  59         app = ec.register_resource("LinuxApplication")
  60         cmd = "echo 'HOLA'"
  61         ec.set(app, "command", cmd)
  62         ec.register_connection(app, node)
  63
  64         ec.deploy()
  65
  66         ec.wait_finished([app])
  67
  68         self.assertTrue(ec.state(node) == ResourceState.STARTED)
  69         self.assertTrue(ec.state(app) == ResourceState.FINISHED)
  70
  71         stdout = ec.trace(app, 'stdout')
  72         self.assertTrue(stdout.strip() == "HOLA")
  73
  74         ec.shutdown()
  75
  76     @skipIfNotAlive
  77     def t_ping(self, host, user):
  78         from nepi.execution.resource import ResourceFactory
  79
  80         ResourceFactory.register_type(LinuxNode)
  81         ResourceFactory.register_type(LinuxApplication)
  82
  83         ec = ExperimentController()
  84
  85         node = ec.register_resource("LinuxNode")
  86         ec.set(node, "hostname", host)
  87         ec.set(node, "username", user)
  88         ec.set(node, "cleanHome", True)
  89         ec.set(node, "cleanProcesses", True)
  90
  91         app = ec.register_resource("LinuxApplication")
  92         cmd = "ping -c5 %s" % self.target
  93         ec.set(app, "command", cmd)
  94
  95         ec.register_connection(app, node)
  96
  97         ec.deploy()
  98
  99         ec.wait_finished([app])
 100
 101         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 102         self.assertTrue(ec.state(app) == ResourceState.FINISHED)
 103
 104         stdout = ec.trace(app, 'stdout')
 105         size = ec.trace(app, 'stdout', attr = TraceAttr.SIZE)
 106         self.assertEquals(len(stdout), size)
 107
 108         block = ec.trace(app, 'stdout', attr = TraceAttr.STREAM, block = 5, offset = 1)
 109         self.assertEquals(block, stdout[5:10])
 110
 111         path = ec.trace(app, 'stdout', attr = TraceAttr.PATH)
 112         rm = ec.get_resource(app)
 113         p = os.path.join(rm.app_home, 'stdout')
 114         self.assertEquals(path, p)
 115
 116         ec.shutdown()
 117
 118     @skipIfNotAlive
 119     def t_concurrency(self, host, user):
 120         from nepi.execution.resource import ResourceFactory
 121
 122         ResourceFactory.register_type(LinuxNode)
 123         ResourceFactory.register_type(LinuxApplication)
 124
 125         ec = ExperimentController()
 126
 127         node = ec.register_resource("LinuxNode")
 128         ec.set(node, "hostname", host)
 129         ec.set(node, "username", user)
 130         ec.set(node, "cleanHome", True)
 131         ec.set(node, "cleanProcesses", True)
 132
 133         apps = list()
 134         for i in xrange(50):
 135             app = ec.register_resource("LinuxApplication")
 136             cmd = "ping -c5 %s" % self.target
 137             ec.set(app, "command", cmd)
 138             ec.register_connection(app, node)
 139             apps.append(app)
 140
 141         ec.deploy()
 142
 143         ec.wait_finished(apps)
 144
 145         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 146         self.assertTrue(
 147                all([ec.state(guid) == ResourceState.FINISHED \
 148                 for guid in apps])
 149                 )
 150
 151         for app in apps:
 152             stdout = ec.trace(app, 'stdout')
 153             size = ec.trace(app, 'stdout', attr = TraceAttr.SIZE)
 154             self.assertEquals(len(stdout), size)
 155
 156             block = ec.trace(app, 'stdout', attr = TraceAttr.STREAM, block = 5, offset = 1)
 157             self.assertEquals(block, stdout[5:10])
 158
 159             path = ec.trace(app, 'stdout', attr = TraceAttr.PATH)
 160             rm = ec.get_resource(app)
 161             p = os.path.join(rm.app_home, 'stdout')
 162             self.assertEquals(path, p)
 163
 164         ec.shutdown()
 165
 166     @skipIfNotAlive
 167     def t_condition(self, host, user, depends):
 168         from nepi.execution.resource import ResourceFactory
 169
 170         ResourceFactory.register_type(LinuxNode)
 171         ResourceFactory.register_type(LinuxApplication)
 172
 173         ec = ExperimentController()
 174
 175         node = ec.register_resource("LinuxNode")
 176         ec.set(node, "hostname", host)
 177         ec.set(node, "username", user)
 178         ec.set(node, "cleanHome", True)
 179         ec.set(node, "cleanProcesses", True)
 180
 181         server = ec.register_resource("LinuxApplication")
 182         cmd = "echo 'HOLA' | nc -l 3333"
 183         ec.set(server, "command", cmd)
 184         ec.set(server, "depends", depends)
 185         ec.register_connection(server, node)
 186
 187         client = ec.register_resource("LinuxApplication")
 188         cmd = "nc 127.0.0.1 3333"
 189         ec.set(client, "command", cmd)
 190         ec.register_connection(client, node)
 191
 192         ec.register_condition(client, ResourceAction.START, server, ResourceState.STARTED)
 193
 194         apps = [client, server]
 195
 196         ec.deploy()
 197
 198         ec.wait_finished(apps)
 199
 200         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 201         self.assertTrue(ec.state(server) == ResourceState.FINISHED)
 202         self.assertTrue(ec.state(client) == ResourceState.FINISHED)
 203
 204         stdout = ec.trace(client, 'stdout')
 205         self.assertTrue(stdout.strip() == "HOLA")
 206
 207         ec.shutdown()
 208
 209     @skipIfNotAlive
 210     def t_http_sources(self, host, user):
 211         from nepi.execution.resource import ResourceFactory
 212
 213         ResourceFactory.register_type(LinuxNode)
 214         ResourceFactory.register_type(LinuxApplication)
 215
 216         ec = ExperimentController()
 217
 218         node = ec.register_resource("LinuxNode")
 219         ec.set(node, "hostname", host)
 220         ec.set(node, "username", user)
 221         ec.set(node, "cleanHome", True)
 222         ec.set(node, "cleanProcesses", True)
 223
 224         sources = "http://nepi.inria.fr/attachment/wiki/WikiStart/pybindgen-r794.tar.gz " \
 225             "http://nepi.inria.fr/attachment/wiki/WikiStart/nepi_integration_framework.pdf"
 226
 227         app = ec.register_resource("LinuxApplication")
 228         ec.set(app, "sources", sources)
 229
 230         ec.register_connection(app, node)
 231
 232         ec.deploy()
 233
 234         ec.wait_finished([app])
 235
 236         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 237         self.assertTrue(ec.state(app) == ResourceState.FINISHED)
 238
 239         err = ec.trace(app, 'http_sources_err')
 240         self.assertTrue(err == "")
 241
 242         out = ec.trace(app, 'http_sources_out')
 243         self.assertTrue(out.find("pybindgen-r794.tar.gz") > -1)
 244         self.assertTrue(out.find("nepi_integration_framework.pdf") > -1)
 245
 246         ec.shutdown()
 247
 248     def test_stdout_fedora(self):
 249         self.t_stdout(self.fedora_host, self.fedora_user)
 250
 251     def test_stdout_ubuntu(self):
 252         self.t_stdout(self.ubuntu_host, self.ubuntu_user)
 253
 254     def test_ping_fedora(self):
 255         self.t_ping(self.fedora_host, self.fedora_user)
 256
 257     def test_ping_ubuntu(self):
 258         self.t_ping(self.ubuntu_host, self.ubuntu_user)
 259
 260     def test_concurrency_fedora(self):
 261         self.t_concurrency(self.fedora_host, self.fedora_user)
 262
 263     def test_concurrency_ubuntu(self):
 264         self.t_concurrency(self.ubuntu_host, self.ubuntu_user)
 265
 266     def test_condition_fedora(self):
 267         self.t_condition(self.fedora_host, self.fedora_user, "nc")
 268
 269     def test_condition_ubuntu(self):
 270         self.t_condition(self.ubuntu_host, self.ubuntu_user, "netcat")
 271
 272     def test_http_sources_fedora(self):
 273         self.t_http_sources(self.fedora_host, self.fedora_user)
 274
 275     def test_http_sources_ubuntu(self):
 276         self.t_http_sources(self.ubuntu_host, self.ubuntu_user)
 277
 278
 279     # TODO: test compilation, sources, dependencies, etc!!!
 280
 281 if __name__ == '__main__':
 282     unittest.main()
 283