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()
  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()
  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.app_home, "stdout")
 115         self.assertEquals(path, p)
 116
 117         ec.shutdown()
 118
 119     @skipIfNotAlive
 120     def t_concurrency(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()
 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         apps = list()
 135         for i in xrange(50):
 136             app = ec.register_resource("LinuxApplication")
 137             cmd = "ping -c5 %s" % self.target
 138             ec.set(app, "command", cmd)
 139             ec.register_connection(app, node)
 140             apps.append(app)
 141
 142         ec.deploy()
 143
 144         ec.wait_finished(apps)
 145
 146         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 147         self.assertTrue(
 148                all([ec.state(guid) == ResourceState.FINISHED \
 149                 for guid in apps])
 150                 )
 151
 152         for app in apps:
 153             stdout = ec.trace(app, 'stdout')
 154             size = ec.trace(app, 'stdout', attr = TraceAttr.SIZE)
 155             self.assertEquals(len(stdout), size)
 156
 157             block = ec.trace(app, 'stdout', attr = TraceAttr.STREAM, block = 5, offset = 1)
 158             self.assertEquals(block, stdout[5:10])
 159
 160             path = ec.trace(app, 'stdout', attr = TraceAttr.PATH)
 161             rm = ec.get_resource(app)
 162             p = os.path.join(rm.app_home, 'stdout')
 163             self.assertEquals(path, p)
 164
 165         ec.shutdown()
 166
 167     @skipIfNotAlive
 168     def t_condition(self, host, user, depends):
 169         from nepi.execution.resource import ResourceFactory
 170
 171         ResourceFactory.register_type(LinuxNode)
 172         ResourceFactory.register_type(LinuxApplication)
 173
 174         ec = ExperimentController()
 175
 176         node = ec.register_resource("LinuxNode")
 177         ec.set(node, "hostname", host)
 178         ec.set(node, "username", user)
 179         ec.set(node, "cleanHome", True)
 180         ec.set(node, "cleanProcesses", True)
 181
 182         server = ec.register_resource("LinuxApplication")
 183         cmd = "echo 'HOLA' | nc -l 3333"
 184         ec.set(server, "command", cmd)
 185         ec.set(server, "depends", depends)
 186         ec.register_connection(server, node)
 187
 188         client = ec.register_resource("LinuxApplication")
 189         cmd = "nc 127.0.0.1 3333"
 190         ec.set(client, "command", cmd)
 191         ec.register_connection(client, node)
 192
 193         ec.register_condition(client, ResourceAction.START, server, ResourceState.STARTED)
 194
 195         apps = [client, server]
 196
 197         ec.deploy()
 198
 199         ec.wait_finished(apps)
 200
 201         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 202         self.assertTrue(ec.state(server) == ResourceState.FINISHED)
 203         self.assertTrue(ec.state(client) == ResourceState.FINISHED)
 204
 205         stdout = ec.trace(client, "stdout")
 206         self.assertTrue(stdout.strip() == "HOLA")
 207
 208         ec.shutdown()
 209
 210     @skipIfNotAlive
 211     def t_http_sources(self, host, user):
 212         from nepi.execution.resource import ResourceFactory
 213
 214         ResourceFactory.register_type(LinuxNode)
 215         ResourceFactory.register_type(LinuxApplication)
 216
 217         ec = ExperimentController()
 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         sources = "http://nepi.inria.fr/code/nef/archive/tip.tar.gz " \
 226                 " http://nepi.inria.fr/code/nef/raw-file/8ace577d4079/src/nef/images/menu/connect.png"
 227
 228         app = ec.register_resource("LinuxApplication")
 229         ec.set(app, "sources", sources)
 230
 231         ec.register_connection(app, node)
 232
 233         ec.deploy()
 234
 235         ec.wait_finished([app])
 236
 237         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 238         self.assertTrue(ec.state(app) == ResourceState.FINISHED)
 239
 240         exitcode = ec.trace(app, "http_sources_exitcode")
 241         self.assertTrue(exitcode.strip() == "0")
 242
 243         out = ec.trace(app, "http_sources_stdout")
 244         self.assertTrue(out.find("tip.tar.gz") > -1)
 245         self.assertTrue(out.find("connect.png") > -1)
 246
 247         ec.shutdown()
 248
 249     @skipIfNotAlive
 250     def t_xterm(self, host, user):
 251         from nepi.execution.resource import ResourceFactory
 252
 253         ResourceFactory.register_type(LinuxNode)
 254         ResourceFactory.register_type(LinuxApplication)
 255
 256         ec = ExperimentController()
 257
 258         node = ec.register_resource("LinuxNode")
 259         ec.set(node, "hostname", host)
 260         ec.set(node, "username", user)
 261         ec.set(node, "cleanHome", True)
 262         ec.set(node, "cleanProcesses", True)
 263
 264         app = ec.register_resource("LinuxApplication")
 265         ec.set(app, "command", "xterm")
 266         ec.set(app, "depends", "xterm")
 267         ec.set(app, "forwardX11", True)
 268
 269         ec.register_connection(app, node)
 270
 271         ec.deploy()
 272
 273         ec.wait_finished([app])
 274
 275         self.assertTrue(ec.state(app) == ResourceState.FINISHED)
 276
 277         ec.shutdown()
 278
 279     def test_stdout_fedora(self):
 280         self.t_stdout(self.fedora_host, self.fedora_user)
 281
 282     def test_stdout_ubuntu(self):
 283         self.t_stdout(self.ubuntu_host, self.ubuntu_user)
 284
 285     def test_ping_fedora(self):
 286         self.t_ping(self.fedora_host, self.fedora_user)
 287
 288     def test_ping_ubuntu(self):
 289         self.t_ping(self.ubuntu_host, self.ubuntu_user)
 290
 291     def test_concurrency_fedora(self):
 292         self.t_concurrency(self.fedora_host, self.fedora_user)
 293
 294     def test_concurrency_ubuntu(self):
 295         self.t_concurrency(self.ubuntu_host, self.ubuntu_user)
 296
 297     def test_condition_fedora(self):
 298         self.t_condition(self.fedora_host, self.fedora_user, "nc")
 299
 300     def test_condition_ubuntu(self):
 301         self.t_condition(self.ubuntu_host, self.ubuntu_user, "netcat")
 302
 303     def test_http_sources_fedora(self):
 304         self.t_http_sources(self.fedora_host, self.fedora_user)
 305
 306     def test_http_sources_ubuntu(self):
 307         self.t_http_sources(self.ubuntu_host, self.ubuntu_user)
 308
 309     @skipInteractive
 310     def test_xterm_ubuntu(self):
 311         """ Interactive test. Should not run automatically """
 312         self.t_xterm(self.ubuntu_host, self.ubuntu_user)
 313
 314
 315
 316 if __name__ == '__main__':
 317     unittest.main()
 318