test/resources/linux/application.py

   1 #!/usr/bin/env python
   2 #
   3 #    NEPI, a framework to manage network experiments
   4 #    Copyright (C) 2013 INRIA
   5 #
   6 #    This program is free software: you can redistribute it and/or modify
   7 #    it under the terms of the GNU General Public License as published by
   8 #    the Free Software Foundation, either version 3 of the License, or
   9 #    (at your option) any later version.
  10 #
  11 #    This program is distributed in the hope that it will be useful,
  12 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 #    GNU General Public License for more details.
  15 #
  16 #    You should have received a copy of the GNU General Public License
  17 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 #
  19 # Author: Alina Quereilhac <alina.quereilhac@inria.fr>
  20
  21
  22 from nepi.execution.ec import ExperimentController
  23 from nepi.execution.resource import ResourceState, ResourceAction
  24 from nepi.execution.trace import TraceAttr
  25 from nepi.resources.linux.node import LinuxNode
  26 from nepi.resources.linux.application import LinuxApplication
  27
  28 from test_utils import skipIfNotAlive, skipInteractive
  29
  30 import os
  31 import time
  32 import tempfile
  33 import unittest
  34
  35 class LinuxApplicationTestCase(unittest.TestCase):
  36     def setUp(self):
  37         self.fedora_host = "nepi2.pl.sophia.inria.fr"
  38         self.fedora_user = "inria_nepi"
  39
  40         self.ubuntu_host = "roseval.pl.sophia.inria.fr"
  41         self.ubuntu_user = "alina"
  42
  43         self.target = "nepi5.pl.sophia.inria.fr"
  44
  45     @skipIfNotAlive
  46     def t_stdout(self, host, user):
  47         from nepi.execution.resource import ResourceFactory
  48
  49         ResourceFactory.register_type(LinuxNode)
  50         ResourceFactory.register_type(LinuxApplication)
  51
  52         ec = ExperimentController(exp_id = "test-stdout")
  53
  54         node = ec.register_resource("LinuxNode")
  55         ec.set(node, "hostname", host)
  56         ec.set(node, "username", user)
  57         ec.set(node, "cleanHome", True)
  58         ec.set(node, "cleanProcesses", True)
  59
  60         app = ec.register_resource("LinuxApplication")
  61         cmd = "echo 'HOLA'"
  62         ec.set(app, "command", cmd)
  63         ec.register_connection(app, node)
  64
  65         ec.deploy()
  66
  67         ec.wait_finished(app)
  68
  69         self.assertTrue(ec.state(node) == ResourceState.STARTED)
  70         self.assertTrue(ec.state(app) == ResourceState.FINISHED)
  71
  72         stdout = ec.trace(app, "stdout")
  73         self.assertTrue(stdout.strip() == "HOLA")
  74
  75         ec.shutdown()
  76
  77     @skipIfNotAlive
  78     def t_ping(self, host, user):
  79         from nepi.execution.resource import ResourceFactory
  80
  81         ResourceFactory.register_type(LinuxNode)
  82         ResourceFactory.register_type(LinuxApplication)
  83
  84         ec = ExperimentController(exp_id = "test-ping")
  85
  86         node = ec.register_resource("LinuxNode")
  87         ec.set(node, "hostname", host)
  88         ec.set(node, "username", user)
  89         ec.set(node, "cleanHome", True)
  90         ec.set(node, "cleanProcesses", True)
  91
  92         app = ec.register_resource("LinuxApplication")
  93         cmd = "ping -c5 %s" % self.target
  94         ec.set(app, "command", cmd)
  95
  96         ec.register_connection(app, node)
  97
  98         ec.deploy()
  99
 100         ec.wait_finished(app)
 101
 102         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 103         self.assertTrue(ec.state(app) == ResourceState.FINISHED)
 104
 105         stdout = ec.trace(app, "stdout")
 106         size = ec.trace(app, "stdout", attr = TraceAttr.SIZE)
 107         self.assertEquals(len(stdout), size)
 108
 109         block = ec.trace(app, "stdout", attr = TraceAttr.STREAM, block = 5, offset = 1)
 110         self.assertEquals(block, stdout[5:10])
 111
 112         path = ec.trace(app, "stdout", attr = TraceAttr.PATH)
 113         rm = ec.get_resource(app)
 114         p = os.path.join(rm.run_home, "stdout")
 115         self.assertEquals(path, p)
 116
 117         ec.shutdown()
 118
 119     @skipIfNotAlive
 120     def t_code(self, host, user):
 121         from nepi.execution.resource import ResourceFactory
 122
 123         ResourceFactory.register_type(LinuxNode)
 124         ResourceFactory.register_type(LinuxApplication)
 125
 126         ec = ExperimentController(exp_id = "tests-code")
 127
 128         node = ec.register_resource("LinuxNode")
 129         ec.set(node, "hostname", host)
 130         ec.set(node, "username", user)
 131         ec.set(node, "cleanHome", True)
 132         ec.set(node, "cleanProcesses", True)
 133
 134         prog = """#include <stdio.h>
 135
 136 int
 137 main (void)
 138 {
 139     printf ("Hello, world!\\n");
 140     return 0;
 141 }
 142 """
 143         cmd = "${RUN_HOME}/hello"
 144         build = "gcc -Wall -x c ${APP_HOME}/code -o hello"
 145
 146         app = ec.register_resource("LinuxApplication")
 147         ec.set(app, "command", cmd)
 148         ec.set(app, "code", prog)
 149         ec.set(app, "depends", "gcc")
 150         ec.set(app, "build", build)
 151         ec.register_connection(app, node)
 152
 153         ec.deploy()
 154
 155         ec.wait_finished(app)
 156
 157         out = ec.trace(app, 'stdout')
 158         self.assertEquals(out, "Hello, world!\n")
 159
 160         ec.shutdown()
 161
 162     @skipIfNotAlive
 163     def t_concurrency(self, host, user):
 164         from nepi.execution.resource import ResourceFactory
 165
 166         ResourceFactory.register_type(LinuxNode)
 167         ResourceFactory.register_type(LinuxApplication)
 168
 169         ec = ExperimentController(exp_id="test-concurrency")
 170
 171         node = ec.register_resource("LinuxNode")
 172         ec.set(node, "hostname", host)
 173         ec.set(node, "username", user)
 174         ec.set(node, "cleanHome", True)
 175         ec.set(node, "cleanProcesses", True)
 176
 177         apps = list()
 178         for i in xrange(50):
 179             app = ec.register_resource("LinuxApplication")
 180             cmd = "ping -c5 %s" % self.target
 181             ec.set(app, "command", cmd)
 182             ec.register_connection(app, node)
 183             apps.append(app)
 184
 185         ec.deploy()
 186
 187         ec.wait_finished(apps)
 188
 189         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 190         self.assertTrue(
 191                all([ec.state(guid) == ResourceState.FINISHED \
 192                 for guid in apps])
 193                 )
 194
 195         for app in apps:
 196             stdout = ec.trace(app, 'stdout')
 197             size = ec.trace(app, 'stdout', attr = TraceAttr.SIZE)
 198             self.assertEquals(len(stdout), size)
 199
 200             block = ec.trace(app, 'stdout', attr = TraceAttr.STREAM, block = 5, offset = 1)
 201             self.assertEquals(block, stdout[5:10])
 202
 203             path = ec.trace(app, 'stdout', attr = TraceAttr.PATH)
 204             rm = ec.get_resource(app)
 205             p = os.path.join(rm.run_home, 'stdout')
 206             self.assertEquals(path, p)
 207
 208         ec.shutdown()
 209
 210     @skipIfNotAlive
 211     def t_condition(self, host, user, depends):
 212         from nepi.execution.resource import ResourceFactory
 213
 214         ResourceFactory.register_type(LinuxNode)
 215         ResourceFactory.register_type(LinuxApplication)
 216
 217         ec = ExperimentController(exp_id="test-condition")
 218
 219         node = ec.register_resource("LinuxNode")
 220         ec.set(node, "hostname", host)
 221         ec.set(node, "username", user)
 222         ec.set(node, "cleanHome", True)
 223         ec.set(node, "cleanProcesses", True)
 224
 225         server = ec.register_resource("LinuxApplication")
 226         cmd = "echo 'HOLA' | nc -l 3333"
 227         ec.set(server, "command", cmd)
 228         ec.set(server, "depends", depends)
 229         ec.register_connection(server, node)
 230
 231         client = ec.register_resource("LinuxApplication")
 232         cmd = "nc 127.0.0.1 3333"
 233         ec.set(client, "command", cmd)
 234         ec.register_connection(client, node)
 235
 236         ec.register_condition(client, ResourceAction.START, server, ResourceState.STARTED)
 237
 238         apps = [client, server]
 239
 240         ec.deploy()
 241
 242         ec.wait_finished(apps)
 243
 244         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 245         self.assertTrue(ec.state(server) == ResourceState.FINISHED)
 246         self.assertTrue(ec.state(client) == ResourceState.FINISHED)
 247
 248         stdout = ec.trace(client, "stdout")
 249         self.assertTrue(stdout.strip() == "HOLA")
 250
 251         ec.shutdown()
 252
 253     @skipIfNotAlive
 254     def t_http_sources(self, host, user):
 255         from nepi.execution.resource import ResourceFactory
 256
 257         ResourceFactory.register_type(LinuxNode)
 258         ResourceFactory.register_type(LinuxApplication)
 259
 260         ec = ExperimentController(exp_id="test-http-sources")
 261
 262         node = ec.register_resource("LinuxNode")
 263         ec.set(node, "hostname", host)
 264         ec.set(node, "username", user)
 265         ec.set(node, "cleanHome", True)
 266         ec.set(node, "cleanProcesses", True)
 267
 268         sources = "http://nepi.inria.fr/code/nef/archive/tip.tar.gz " \
 269                 " http://nepi.inria.fr/code/nef/raw-file/8ace577d4079/src/nef/images/menu/connect.png"
 270
 271         app = ec.register_resource("LinuxApplication")
 272         ec.set(app, "sources", sources)
 273
 274         ec.register_connection(app, node)
 275
 276         ec.deploy()
 277
 278         ec.wait_finished([app])
 279
 280         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 281         self.assertTrue(ec.state(app) == ResourceState.FINISHED)
 282
 283         exitcode = ec.trace(app, "deploy_exitcode")
 284         self.assertTrue(exitcode.strip() == "0")
 285
 286         out = ec.trace(app, "deploy_stdout")
 287         self.assertTrue(out.find("tip.tar.gz") > -1)
 288         self.assertTrue(out.find("connect.png") > -1)
 289
 290         ec.shutdown()
 291
 292     @skipIfNotAlive
 293     def t_xterm(self, host, user):
 294         from nepi.execution.resource import ResourceFactory
 295
 296         ResourceFactory.register_type(LinuxNode)
 297         ResourceFactory.register_type(LinuxApplication)
 298
 299         ec = ExperimentController(exp_id="test-xterm")
 300
 301         node = ec.register_resource("LinuxNode")
 302         ec.set(node, "hostname", host)
 303         ec.set(node, "username", user)
 304         ec.set(node, "cleanHome", True)
 305         ec.set(node, "cleanProcesses", True)
 306
 307         app = ec.register_resource("LinuxApplication")
 308         ec.set(app, "command", "xterm")
 309         ec.set(app, "depends", "xterm")
 310         ec.set(app, "forwardX11", True)
 311
 312         ec.register_connection(app, node)
 313
 314         ec.deploy()
 315
 316         ec.wait_finished([app])
 317
 318         self.assertTrue(ec.state(app) == ResourceState.FINISHED)
 319
 320         ec.shutdown()
 321
 322     def test_stdout_fedora(self):
 323         self.t_stdout(self.fedora_host, self.fedora_user)
 324
 325     def test_stdout_ubuntu(self):
 326         self.t_stdout(self.ubuntu_host, self.ubuntu_user)
 327
 328     def test_ping_fedora(self):
 329         self.t_ping(self.fedora_host, self.fedora_user)
 330
 331     def test_ping_ubuntu(self):
 332         self.t_ping(self.ubuntu_host, self.ubuntu_user)
 333
 334     def test_concurrency_fedora(self):
 335         self.t_concurrency(self.fedora_host, self.fedora_user)
 336
 337     def test_concurrency_ubuntu(self):
 338         self.t_concurrency(self.ubuntu_host, self.ubuntu_user)
 339
 340     def test_condition_fedora(self):
 341         self.t_condition(self.fedora_host, self.fedora_user, "nc")
 342
 343     def test_condition_ubuntu(self):
 344         self.t_condition(self.ubuntu_host, self.ubuntu_user, "netcat")
 345
 346     def test_http_sources_fedora(self):
 347         self.t_http_sources(self.fedora_host, self.fedora_user)
 348
 349     def test_http_sources_ubuntu(self):
 350         self.t_http_sources(self.ubuntu_host, self.ubuntu_user)
 351
 352     def test_code_fedora(self):
 353         self.t_code(self.fedora_host, self.fedora_user)
 354
 355     def test_code_ubuntu(self):
 356         self.t_code(self.ubuntu_host, self.ubuntu_user)
 357
 358     @skipInteractive
 359     def test_xterm_ubuntu(self):
 360         """ Interactive test. Should not run automatically """
 361         self.t_xterm(self.ubuntu_host, self.ubuntu_user)
 362
 363
 364
 365 if __name__ == '__main__':
 366     unittest.main()
 367